@specific.dev/cli 0.1.66 → 0.1.68

package/dist/cli.js

@@ -238,15 +238,15 @@ var init_wsl_utils = __esm({
       const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
       return stdout.trim();
     };
-    convertWslPathToWindows = async (path28) => {
-      if (/^[a-z]+:\/\//i.test(path28)) {
-        return path28;
+    convertWslPathToWindows = async (path30) => {
+      if (/^[a-z]+:\/\//i.test(path30)) {
+        return path30;
       }
       try {
-        const { stdout } = await execFile2("wslpath", ["-aw", path28], { encoding: "utf8" });
+        const { stdout } = await execFile2("wslpath", ["-aw", path30], { encoding: "utf8" });
         return stdout.trim();
       } catch {
-        return path28;
+        return path30;
       }
     };
   }
@@ -754,8 +754,8 @@ var require_dist = __commonJS({
       var $global, $module, $NaN = NaN;
       if ("undefined" != typeof window ? $global = window : "undefined" != typeof self ? $global = self : "undefined" != typeof global ? ($global = global).require = __require : $global = this, void 0 === $global || void 0 === $global.Array) throw new Error("no global object found");
       if ("undefined" != typeof module && ($module = module), !$global.fs && $global.require) try {
-        var fs30 = $global.require("fs");
-        "object" == typeof fs30 && null !== fs30 && 0 !== Object.keys(fs30).length && ($global.fs = fs30);
+        var fs32 = $global.require("fs");
+        "object" == typeof fs32 && null !== fs32 && 0 !== Object.keys(fs32).length && ($global.fs = fs32);
       } catch (e) {
       }
       if (!$global.fs) {
@@ -183423,7 +183423,7 @@ ${frame}`;
   }
 });
 
-// src/cli.tsx
+// src/cli-program.tsx
 import { Command } from "commander";
 
 // src/commands/init.tsx
@@ -184496,7 +184496,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.66",
+      cli_version: "0.1.68",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId(),
@@ -184868,6 +184868,10 @@ var BETA_REGISTRY = [
   {
     name: "temporal",
     description: "Managed Temporal workflow engine for durable workflows and background tasks"
+  },
+  {
+    name: "mail",
+    description: "Managed email sending via SMTP for transactional emails"
   }
 ];
 
@@ -184914,20 +184918,20 @@ function saveBetas(enabled, projectDir) {
 // src/commands/docs.tsx
 var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
 var docsDir = join8(__dirname2, "docs");
-function docsCommand(path28) {
-  const docPath = resolveDocPath(path28);
-  if (!docPath) {
+var _embeddedDocs = null;
+function docsCommand(path30) {
+  const content = resolveDocContent(path30);
+  if (!content) {
     console.error(
-      `Documentation not found: ${path28 || "index"}
+      `Documentation not found: ${path30 || "index"}
 
 Run 'specific docs' to see available topics.`
     );
     process.exit(1);
   }
   const enabledBetas = new Set(loadEnabledBetas());
-  let content = readFileSync6(docPath, "utf-8");
-  content = filterBetaTags(content, enabledBetas);
-  console.log(content);
+  const filtered = filterBetaTags(content, enabledBetas);
+  console.log(filtered);
 }
 function filterBetaTags(content, enabledBetas) {
   return content.replace(
@@ -184937,18 +184941,33 @@ function filterBetaTags(content, enabledBetas) {
     }
   );
 }
-function resolveDocPath(path28) {
-  if (!path28) {
+function resolveDocContent(path30) {
+  const normalized = path30?.replace(/^\/+|\/+$/g, "") || void 0;
+  if (_embeddedDocs) {
+    return resolveEmbeddedDoc(normalized);
+  }
+  return resolveFilesystemDoc(normalized);
+}
+function resolveEmbeddedDoc(path30) {
+  if (!path30) {
+    return _embeddedDocs.get("index.md") ?? null;
+  }
+  const direct = _embeddedDocs.get(`${path30}.md`);
+  if (direct) return direct;
+  return _embeddedDocs.get(`${path30}/index.md`) ?? null;
+}
+function resolveFilesystemDoc(path30) {
+  if (!path30) {
     const indexPath2 = join8(docsDir, "index.md");
-    return existsSync7(indexPath2) ? indexPath2 : null;
+    return existsSync7(indexPath2) ? readFileSync6(indexPath2, "utf-8") : null;
   }
-  const directPath = join8(docsDir, `${path28}.md`);
+  const directPath = join8(docsDir, `${path30}.md`);
   if (existsSync7(directPath)) {
-    return directPath;
+    return readFileSync6(directPath, "utf-8");
   }
-  const indexPath = join8(docsDir, path28, "index.md");
+  const indexPath = join8(docsDir, path30, "index.md");
   if (existsSync7(indexPath)) {
-    return indexPath;
+    return readFileSync6(indexPath, "utf-8");
   }
   return null;
 }
@@ -185073,6 +185092,17 @@ function parseReferenceString(str) {
       };
     }
   }
+  const mailMatch = str.match(new RegExp(`^mail\\.(${id})\\.(\\w+)$`));
+  if (mailMatch && mailMatch[1] && mailMatch[2]) {
+    const attr = mailMatch[2];
+    if (["host", "port", "user", "password", "from"].includes(attr)) {
+      return {
+        type: "mail",
+        name: mailMatch[1],
+        attribute: attr
+      };
+    }
+  }
   const volumeMatch = str.match(new RegExp(`^volume\\.(${id})\\.(\\w+)$`));
   if (volumeMatch && volumeMatch[1] && volumeMatch[2]) {
     const attr = volumeMatch[2];
@@ -185117,7 +185147,7 @@ function parseReferenceString(str) {
       attribute: serviceMatch[2]
     };
   }
-  const knownPrefixes = ["build", "postgres", "redis", "storage", "temporal", "volume", "config", "secret", "endpoint", "service"];
+  const knownPrefixes = ["build", "postgres", "redis", "storage", "temporal", "mail", "volume", "config", "secret", "endpoint", "service"];
   const prefixMatch = str.match(/^(\w+)\./);
   if (prefixMatch && knownPrefixes.includes(prefixMatch[1])) {
     throw new Error(`Invalid reference "\${${str}}". The prefix "${prefixMatch[1]}" is recognized but the reference format is invalid.`);
@@ -185467,6 +185497,16 @@ function parseTemporal(data) {
   }
   return result;
 }
+function parseMail(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return [];
+  }
+  const result = [];
+  for (const [name] of Object.entries(data)) {
+    result.push({ name });
+  }
+  return result;
+}
 function parseConfigDevBlock(dev) {
   if (!dev) {
     return void 0;
@@ -185579,6 +185619,7 @@ async function parseConfig(hcl) {
     redis: parseRedis(json.redis),
     storage: parseStorage(json.storage),
     temporal: parseTemporal(json.temporal),
+    mail: parseMail(json.mail),
     configs: parseConfigs(json.config),
     secrets: parseSecrets(json.secret),
     environments: parseEnvironments(json.environment)
@@ -186333,7 +186374,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path28) => statMethod(path28, { bigint: true });
+      this._stat = (path30) => statMethod(path30, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -186358,8 +186399,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path28, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path28));
+          const { path: path30, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path30));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -186399,20 +186440,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path28, depth) {
+  async _exploreDir(path30, depth) {
     let files;
     try {
-      files = await readdir(path28, this._rdOptions);
+      files = await readdir(path30, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path28 };
+    return { files, depth, path: path30 };
   }
-  async _formatEntry(dirent, path28) {
+  async _formatEntry(dirent, path30) {
     let entry;
     const basename6 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path28, basename6));
+      const fullPath = presolve(pjoin(path30, basename6));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -186812,16 +186853,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path28, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path30, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path28);
-    emitRaw(rawEvent, evPath, { watchedPath: path28 });
-    if (evPath && path28 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path28, evPath), KEY_LISTENERS, sp.join(path28, evPath));
+    listener(path30);
+    emitRaw(rawEvent, evPath, { watchedPath: path30 });
+    if (evPath && path30 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path30, evPath), KEY_LISTENERS, sp.join(path30, evPath));
     }
   };
   try {
-    return fs_watch(path28, {
+    return fs_watch(path30, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error) {
@@ -186837,12 +186878,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path28, fullPath, options2, handlers) => {
+var setFsWatchListener = (path30, fullPath, options2, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options2.persistent) {
-    watcher = createFsWatchInstance(path28, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path30, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -186853,7 +186894,7 @@ var setFsWatchListener = (path28, fullPath, options2, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path28,
+      path30,
       options2,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -186868,7 +186909,7 @@ var setFsWatchListener = (path28, fullPath, options2, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open2(path28, "r");
+          const fd = await open2(path30, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -186899,7 +186940,7 @@ var setFsWatchListener = (path28, fullPath, options2, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path28, fullPath, options2, handlers) => {
+var setFsWatchFileListener = (path30, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -186921,7 +186962,7 @@ var setFsWatchFileListener = (path28, fullPath, options2, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path28, curr));
+          foreach(cont.listeners, (listener2) => listener2(path30, curr));
         }
       })
     };
@@ -186951,13 +186992,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path28, listener) {
+  _watchWithNodeFs(path30, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path28);
-    const basename6 = sp.basename(path28);
+    const directory = sp.dirname(path30);
+    const basename6 = sp.basename(path30);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename6);
-    const absolutePath = sp.resolve(path28);
+    const absolutePath = sp.resolve(path30);
     const options2 = {
       persistent: opts.persistent
     };
@@ -186967,12 +187008,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options2.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path28, absolutePath, options2, {
+      closer = setFsWatchFileListener(path30, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path28, absolutePath, options2, {
+      closer = setFsWatchListener(path30, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -186988,13 +187029,13 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname9 = sp.dirname(file);
+    const dirname10 = sp.dirname(file);
     const basename6 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname9);
+    const parent = this.fsw._getWatchedDir(dirname10);
     let prevStats = stats;
     if (parent.has(basename6))
       return;
-    const listener = async (path28, newStats) => {
+    const listener = async (path30, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -187008,16 +187049,16 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path28);
+            this.fsw._closeFile(path30);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path28, closer2);
+              this.fsw._addPathCloser(path30, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname9, basename6);
+          this.fsw._remove(dirname10, basename6);
         }
       } else if (parent.has(basename6)) {
         const at = newStats.atimeMs;
@@ -187044,7 +187085,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path28, item) {
+  async _handleSymlink(entry, directory, path30, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -187054,7 +187095,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path28);
+        linkPath = await fsrealpath(path30);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -187064,12 +187105,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path28, entry.stats);
+          this.fsw._emit(EV.CHANGE, path30, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path28, entry.stats);
+        this.fsw._emit(EV.ADD, path30, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -187099,9 +187140,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path28 = sp.join(directory, item);
+      let path30 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path28, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path30, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -187110,8 +187151,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path28 = sp.join(dir, sp.relative(dir, path28));
-        this._addToNodeFs(path28, initialAdd, wh, depth + 1);
+        path30 = sp.join(dir, sp.relative(dir, path30));
+        this._addToNodeFs(path30, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve10, reject) => {
@@ -187180,13 +187221,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path28, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path30, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path28) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path30) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path28);
+    const wh = this.fsw._getWatchHelpers(path30);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -187202,8 +187243,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path28);
-        const targetPath = follow ? await fsrealpath(path28) : path28;
+        const absPath = sp.resolve(path30);
+        const targetPath = follow ? await fsrealpath(path30) : path30;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -187213,29 +187254,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path28) : path28;
+        const targetPath = follow ? await fsrealpath(path30) : path30;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path28, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path30, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path28), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path30), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path28, closer);
+        this.fsw._addPathCloser(path30, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path28;
+        return path30;
       }
     }
   }
@@ -187278,24 +187319,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path28) {
-  if (typeof path28 !== "string")
+function normalizePath(path30) {
+  if (typeof path30 !== "string")
     throw new Error("string expected");
-  path28 = sp2.normalize(path28);
-  path28 = path28.replace(/\\/g, "/");
+  path30 = sp2.normalize(path30);
+  path30 = path30.replace(/\\/g, "/");
   let prepend = false;
-  if (path28.startsWith("//"))
+  if (path30.startsWith("//"))
     prepend = true;
-  path28 = path28.replace(DOUBLE_SLASH_RE, "/");
+  path30 = path30.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path28 = "/" + path28;
-  return path28;
+    path30 = "/" + path30;
+  return path30;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path28 = normalizePath(testString);
+  const path30 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path28, stats)) {
+    if (pattern(path30, stats)) {
       return true;
     }
   }
@@ -187333,19 +187374,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path28) => toUnix(sp2.normalize(toUnix(path28)));
-var normalizeIgnored = (cwd = "") => (path28) => {
-  if (typeof path28 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path28) ? path28 : sp2.join(cwd, path28));
+var normalizePathToUnix = (path30) => toUnix(sp2.normalize(toUnix(path30)));
+var normalizeIgnored = (cwd = "") => (path30) => {
+  if (typeof path30 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path30) ? path30 : sp2.join(cwd, path30));
   } else {
-    return path28;
+    return path30;
   }
 };
-var getAbsolutePath = (path28, cwd) => {
-  if (sp2.isAbsolute(path28)) {
-    return path28;
+var getAbsolutePath = (path30, cwd) => {
+  if (sp2.isAbsolute(path30)) {
+    return path30;
   }
-  return sp2.join(cwd, path28);
+  return sp2.join(cwd, path30);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -187410,10 +187451,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path28, follow, fsw) {
+  constructor(path30, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path28;
-    this.path = path28 = path28.replace(REPLACER_RE, "");
+    const watchPath = path30;
+    this.path = path30 = path30.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -187553,20 +187594,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path28) => {
-        const absPath = getAbsolutePath(path28, cwd);
+      paths = paths.map((path30) => {
+        const absPath = getAbsolutePath(path30, cwd);
         return absPath;
       });
     }
-    paths.forEach((path28) => {
-      this._removeIgnoredPath(path28);
+    paths.forEach((path30) => {
+      this._removeIgnoredPath(path30);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path28) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path28, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path30) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path30, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -187588,17 +187629,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path28) => {
-      if (!sp2.isAbsolute(path28) && !this._closers.has(path28)) {
+    paths.forEach((path30) => {
+      if (!sp2.isAbsolute(path30) && !this._closers.has(path30)) {
         if (cwd)
-          path28 = sp2.join(cwd, path28);
-        path28 = sp2.resolve(path28);
+          path30 = sp2.join(cwd, path30);
+        path30 = sp2.resolve(path30);
       }
-      this._closePath(path28);
-      this._addIgnoredPath(path28);
-      if (this._watched.has(path28)) {
+      this._closePath(path30);
+      this._addIgnoredPath(path30);
+      if (this._watched.has(path30)) {
         this._addIgnoredPath({
-          path: path28,
+          path: path30,
           recursive: true
         });
       }
@@ -187662,38 +187703,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path28, stats) {
+  async _emit(event, path30, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path28 = sp2.normalize(path28);
+      path30 = sp2.normalize(path30);
     if (opts.cwd)
-      path28 = sp2.relative(opts.cwd, path28);
-    const args = [path28];
+      path30 = sp2.relative(opts.cwd, path30);
+    const args = [path30];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path28))) {
+    if (awf && (pw = this._pendingWrites.get(path30))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path28, [event, ...args]);
+        this._pendingUnlinks.set(path30, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path29) => {
+          this._pendingUnlinks.forEach((entry, path31) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path29);
+            this._pendingUnlinks.delete(path31);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path28)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path30)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path28);
+        this._pendingUnlinks.delete(path30);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -187711,16 +187752,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path28, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path30, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path28, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path30, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path28) : path28;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path30) : path30;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -187751,23 +187792,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path28, timeout) {
+  _throttle(actionType, path30, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path28);
+    const actionPath = action.get(path30);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path28);
+      const item = action.get(path30);
       const count = item ? item.count : 0;
-      action.delete(path28);
+      action.delete(path30);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -187775,7 +187816,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path28, thr);
+    action.set(path30, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -187789,44 +187830,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path28, threshold, event, awfEmit) {
+  _awaitWriteFinish(path30, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path28;
-    if (this.options.cwd && !sp2.isAbsolute(path28)) {
-      fullPath = sp2.join(this.options.cwd, path28);
+    let fullPath = path30;
+    if (this.options.cwd && !sp2.isAbsolute(path30)) {
+      fullPath = sp2.join(this.options.cwd, path30);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path28)) {
+        if (err || !writes.has(path30)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path28).lastChange = now2;
+          writes.get(path30).lastChange = now2;
         }
-        const pw = writes.get(path28);
+        const pw = writes.get(path30);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path28);
+          writes.delete(path30);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path28)) {
-      writes.set(path28, {
+    if (!writes.has(path30)) {
+      writes.set(path30, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path28);
+          writes.delete(path30);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -187837,8 +187878,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path28, stats) {
-    if (this.options.atomic && DOT_RE.test(path28))
+  _isIgnored(path30, stats) {
+    if (this.options.atomic && DOT_RE.test(path30))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -187848,17 +187889,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path28, stats);
+    return this._userIgnored(path30, stats);
   }
-  _isntIgnored(path28, stat4) {
-    return !this._isIgnored(path28, stat4);
+  _isntIgnored(path30, stat4) {
+    return !this._isIgnored(path30, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path28) {
-    return new WatchHelper(path28, this.options.followSymlinks, this);
+  _getWatchHelpers(path30) {
+    return new WatchHelper(path30, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -187890,63 +187931,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path28 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path28);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path28) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path28, 100))
+    const path30 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path30);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path30) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path30, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path28);
+    const wp = this._getWatchedDir(path30);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path28, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path30, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path28;
+    let relPath = path30;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path28);
+      relPath = sp2.relative(this.options.cwd, path30);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path28);
+    this._watched.delete(path30);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path28))
-      this._emit(eventName, path28);
-    this._closePath(path28);
+    if (wasTracked && !this._isIgnored(path30))
+      this._emit(eventName, path30);
+    this._closePath(path30);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path28) {
-    this._closeFile(path28);
-    const dir = sp2.dirname(path28);
-    this._getWatchedDir(dir).remove(sp2.basename(path28));
+  _closePath(path30) {
+    this._closeFile(path30);
+    const dir = sp2.dirname(path30);
+    this._getWatchedDir(dir).remove(sp2.basename(path30));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path28) {
-    const closers = this._closers.get(path28);
+  _closeFile(path30) {
+    const closers = this._closers.get(path30);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path28);
+    this._closers.delete(path30);
   }
-  _addPathCloser(path28, closer) {
+  _addPathCloser(path30, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path28);
+    let list = this._closers.get(path30);
     if (!list) {
       list = [];
-      this._closers.set(path28, list);
+      this._closers.set(path30, list);
     }
     list.push(closer);
   }
@@ -188610,6 +188651,26 @@ function resolveEnvValue(value, resources, secrets, configs, servicePort, servic
           throw new Error(`Unknown temporal attribute: ${String(value.attribute)}`);
       }
     }
+    case "mail": {
+      const mail = resources.get(value.name);
+      if (!mail || mail.type !== "mail") {
+        throw new Error(`Mail "${value.name}" not found`);
+      }
+      switch (value.attribute) {
+        case "host":
+          return mail.host;
+        case "port":
+          return String(mail.port);
+        case "user":
+          return "specific";
+        case "password":
+          return "specific";
+        case "from":
+          return "noreply@localhost";
+        default:
+          throw new Error(`Unknown mail attribute: ${String(value.attribute)}`);
+      }
+    }
     case "config": {
       const configValue = configs.get(value.name);
       if (configValue === void 0) {
@@ -188995,6 +189056,7 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 import httpProxy from "http-proxy";
 var __dirname3 = path13.dirname(fileURLToPath3(import.meta.url));
 var adminDir = path13.join(__dirname3, "admin");
+var _embeddedAdmin = null;
 var HTTP_PORT = 80;
 var HTTPS_PORT = 443;
 var DOMAIN_SUFFIX = ".local.spcf.app";
@@ -189341,6 +189403,48 @@ function sendNotFound(res, requestedService, serviceMap) {
 </html>`);
 }
 function serveStaticFile(res, pathname) {
+  if (_embeddedAdmin) {
+    return serveEmbeddedFile(res, pathname);
+  }
+  return serveFilesystemFile(res, pathname);
+}
+function serveEmbeddedFile(res, pathname) {
+  let filePath = pathname;
+  if (filePath === "/" || filePath.endsWith("/")) {
+    filePath = filePath + "index.html";
+  }
+  const relativePath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+  let content = _embeddedAdmin.get(relativePath);
+  if (content) {
+    const ext = path13.extname(relativePath).toLowerCase();
+    const contentType = MIME_TYPES[ext] || "application/octet-stream";
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(content);
+    return;
+  }
+  content = _embeddedAdmin.get(relativePath + ".html");
+  if (content) {
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(content);
+    return;
+  }
+  const indexKey = relativePath.endsWith("/") ? relativePath + "index.html" : relativePath + "/index.html";
+  content = _embeddedAdmin.get(indexKey);
+  if (content) {
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(content);
+    return;
+  }
+  const notFound = _embeddedAdmin.get("404.html");
+  if (notFound) {
+    res.writeHead(404, { "Content-Type": "text/html" });
+    res.end(notFound);
+    return;
+  }
+  res.writeHead(404, { "Content-Type": "text/html" });
+  res.end("<h1>Not Found</h1>");
+}
+function serveFilesystemFile(res, pathname) {
   let filePath = pathname;
   if (filePath === "/" || filePath.endsWith("/")) {
     filePath = filePath + "index.html";
@@ -189631,16 +189735,144 @@ function sleep3(ms) {
   return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
+// src/lib/dev/mail-manager.ts
+import * as http2 from "http";
+import * as crypto3 from "crypto";
+async function startMailServer(mail, smtpPort, apiPort) {
+  const emails = [];
+  const { SMTPServer } = await import("smtp-server");
+  const { simpleParser } = await import("mailparser");
+  const smtpServer = new SMTPServer({
+    authOptional: true,
+    disabledCommands: ["STARTTLS"],
+    onAuth(auth, _session, callback) {
+      if (auth.username === "specific" && auth.password === "specific") {
+        callback(null, { user: auth.username });
+      } else {
+        callback(new Error("Invalid credentials"));
+      }
+    },
+    onData(stream, session, callback) {
+      let rawData = "";
+      stream.on("data", (chunk) => {
+        rawData += chunk.toString();
+      });
+      stream.on("end", async () => {
+        try {
+          const parsed = await simpleParser(rawData);
+          const email = {
+            id: crypto3.randomUUID(),
+            from: parsed.from?.text ?? "",
+            to: Array.isArray(parsed.to) ? parsed.to.map((addr) => addr.text) : parsed.to ? [parsed.to.text] : [],
+            subject: parsed.subject ?? "(no subject)",
+            text: parsed.text,
+            html: typeof parsed.html === "string" ? parsed.html : void 0,
+            date: parsed.date ?? /* @__PURE__ */ new Date()
+          };
+          emails.push(email);
+        } catch {
+          emails.push({
+            id: crypto3.randomUUID(),
+            from: session.envelope.mailFrom ? session.envelope.mailFrom.address : "",
+            to: session.envelope.rcptTo.map((r) => r.address),
+            subject: "(parse error)",
+            text: rawData,
+            date: /* @__PURE__ */ new Date()
+          });
+        }
+        callback();
+      });
+    }
+  });
+  const httpServer = http2.createServer((req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://localhost:${apiPort}`);
+    if (req.method === "GET" && url.pathname === "/api/emails") {
+      const summaries = [...emails].reverse().map(({ id, from, to, subject, date }) => ({
+        id,
+        from,
+        to,
+        subject,
+        date
+      }));
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(summaries));
+      return;
+    }
+    const emailMatch = url.pathname.match(/^\/api\/emails\/(.+)$/);
+    if (req.method === "GET" && emailMatch) {
+      const email = emails.find((e) => e.id === emailMatch[1]);
+      if (email) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(email));
+      } else {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Email not found" }));
+      }
+      return;
+    }
+    if (req.method === "DELETE" && url.pathname === "/api/emails") {
+      emails.length = 0;
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true }));
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+  await new Promise((resolve10, reject) => {
+    smtpServer.listen(smtpPort, "127.0.0.1", () => resolve10());
+    smtpServer.on("error", reject);
+  });
+  await new Promise((resolve10, reject) => {
+    httpServer.listen(apiPort, "127.0.0.1", () => resolve10());
+    httpServer.on("error", reject);
+  });
+  const stop = async () => {
+    await new Promise((resolve10) => {
+      smtpServer.close(() => resolve10());
+    });
+    await new Promise((resolve10) => {
+      httpServer.close(() => resolve10());
+    });
+  };
+  const resource = {
+    name: mail.name,
+    type: "mail",
+    port: smtpPort,
+    url: `smtp://127.0.0.1:${smtpPort}`,
+    host: "127.0.0.1",
+    user: "",
+    password: "",
+    dbName: mail.name,
+    stop
+  };
+  const mailServer = {
+    smtpPort,
+    apiPort,
+    getEmails: () => emails,
+    stop
+  };
+  return { resource, mailServer };
+}
+
 // src/lib/dev/drizzle-gateway-manager.ts
 import * as net3 from "net";
 import * as fs18 from "fs";
 import * as path15 from "path";
 import { spawn as spawn4 } from "child_process";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function generateStoreJson(postgresInstances) {
-  const storeId = randomUUID();
+  const storeId = randomUUID2();
   const slots = postgresInstances.map((pg) => {
-    const slotId = randomUUID();
+    const slotId = randomUUID2();
     return [
       slotId,
       {
@@ -190158,7 +190390,7 @@ async function stopProcess4(proc) {
 
 // src/lib/dev/resource-starter.ts
 function findRequiredResources(service) {
-  const required = { postgres: [], redis: [], storage: [], temporal: [] };
+  const required = { postgres: [], redis: [], storage: [], temporal: [], mail: [] };
   if (service.env) {
     for (const value of Object.values(service.env)) {
       if (typeof value !== "object" || value === null) continue;
@@ -190172,6 +190404,8 @@ function findRequiredResources(service) {
           required.storage.push(ref.name);
         } else if (ref.type === "temporal" && !required.temporal.includes(ref.name)) {
           required.temporal.push(ref.name);
+        } else if (ref.type === "mail" && !required.mail.includes(ref.name)) {
+          required.mail.push(ref.name);
         }
       }
     }
@@ -190193,26 +190427,30 @@ async function startResources(options2) {
   });
   const resources = /* @__PURE__ */ new Map();
   const electric = /* @__PURE__ */ new Map();
+  const mailServers = /* @__PURE__ */ new Map();
   const startedResources = [];
   const startedElectric = [];
   let postgresConfigs;
   let redisConfigs;
   let storageConfigs;
   let temporalConfigs;
+  let mailConfigs;
   if (selection.mode === "all") {
     postgresConfigs = config.postgres;
     redisConfigs = config.redis;
     storageConfigs = config.storage;
     temporalConfigs = config.temporal;
+    mailConfigs = config.mail;
   } else {
     postgresConfigs = config.postgres.filter((p) => selection.postgres.includes(p.name));
     redisConfigs = config.redis.filter((r) => selection.redis.includes(r.name));
     storageConfigs = config.storage.filter((s) => selection.storage.includes(s.name));
     temporalConfigs = config.temporal.filter((t) => selection.temporal.includes(t.name));
+    mailConfigs = config.mail.filter((m) => selection.mail.includes(m.name));
   }
   for (const pg of postgresConfigs) {
     if (signal?.cancelled) {
-      return { resources, electric, startedResources, startedElectric, cancelled: true };
+      return { resources, electric, mail: mailServers, startedResources, startedElectric, cancelled: true };
     }
     const port = portAllocator.allocate(`postgres:${pg.name}`);
     log(`Starting postgres "${pg.name}" on port ${port}`);
@@ -190246,7 +190484,7 @@ async function startResources(options2) {
   }
   for (const redis of redisConfigs) {
     if (signal?.cancelled) {
-      return { resources, electric, startedResources, startedElectric, cancelled: true };
+      return { resources, electric, mail: mailServers, startedResources, startedElectric, cancelled: true };
     }
     const port = portAllocator.allocate(`redis:${redis.name}`);
     log(`Starting redis "${redis.name}" on port ${port}`);
@@ -190270,7 +190508,7 @@ async function startResources(options2) {
   }
   for (const storage of storageConfigs) {
     if (signal?.cancelled) {
-      return { resources, electric, startedResources, startedElectric, cancelled: true };
+      return { resources, electric, mail: mailServers, startedResources, startedElectric, cancelled: true };
     }
     const port = portAllocator.allocate(`storage:${storage.name}`);
     log(`Starting storage "${storage.name}" on port ${port}`);
@@ -190296,7 +190534,7 @@ async function startResources(options2) {
   }
   if (temporalConfigs.length > 0) {
     if (signal?.cancelled) {
-      return { resources, electric, startedResources, startedElectric, cancelled: true };
+      return { resources, electric, mail: mailServers, startedResources, startedElectric, cancelled: true };
     }
     const grpcPort = portAllocator.allocate("temporal-grpc");
     const uiPort = portAllocator.allocate("temporal-ui");
@@ -190313,11 +190551,36 @@ async function startResources(options2) {
       log(`Temporal namespace "${instance.name}" ready`);
     }
   }
+  for (const mail of mailConfigs) {
+    if (signal?.cancelled) {
+      return { resources, electric, mail: mailServers, startedResources, startedElectric, cancelled: true };
+    }
+    const smtpPort = portAllocator.allocate(`mail-smtp:${mail.name}`);
+    const mailApiPort = portAllocator.allocate(`mail-api:${mail.name}`);
+    log(`Starting mail "${mail.name}" on SMTP port ${smtpPort} (API: ${mailApiPort})`);
+    callbacks.onResourceStarting?.(mail.name, "mail");
+    const { resource, mailServer } = await startMailServer(mail, smtpPort, mailApiPort);
+    resources.set(mail.name, resource);
+    startedResources.push(resource);
+    mailServers.set(mail.name, mailServer);
+    callbacks.onResourceReady?.(mail.name, resource);
+    log(`Mail "${mail.name}" ready`);
+    await stateManager.registerDatabase(mail.name, {
+      engine: "mail",
+      port: smtpPort,
+      host: "127.0.0.1",
+      user: "",
+      password: "",
+      dbName: mail.name,
+      url: `smtp://127.0.0.1:${smtpPort}`,
+      mailApiPort
+    });
+  }
   if (shouldStartElectric) {
     const syncDatabases = detectSyncDatabases(config);
     for (const pgName of syncDatabases) {
       if (signal?.cancelled) {
-        return { resources, electric, startedResources, startedElectric, cancelled: true };
+        return { resources, electric, mail: mailServers, startedResources, startedElectric, cancelled: true };
       }
       const pg = resources.get(pgName);
       if (!pg || pg.type !== "postgres") continue;
@@ -190337,7 +190600,7 @@ async function startResources(options2) {
       log(`Electric sync for "${pgName}" ready at ${electricInstance.url}`);
     }
   }
-  return { resources, electric, startedResources, startedElectric, cancelled: false };
+  return { resources, electric, mail: mailServers, startedResources, startedElectric, cancelled: false };
 }
 
 // src/lib/dev/config-watcher.ts
@@ -190994,12 +191257,14 @@ function SecretInput({ secretName, onSubmit, onCancel }) {
 // src/lib/ui/ConfigInput.tsx
 import React5, { useState as useState4 } from "react";
 import { Box as Box5, Text as Text5, useInput as useInput3 } from "ink";
-function ConfigInput({ configName, onSubmit, onCancel }) {
+function ConfigInput({ configName, defaultValue, onSubmit, onCancel }) {
   const [value, setValue] = useState4("");
   useInput3((input, key) => {
     if (key.return) {
       if (value.trim() !== "") {
         onSubmit(value);
+      } else if (defaultValue !== void 0) {
+        onSubmit(defaultValue);
       }
     } else if (key.escape) {
       onCancel();
@@ -191009,7 +191274,7 @@ function ConfigInput({ configName, onSubmit, onCancel }) {
       setValue((prev) => prev + input);
     }
   });
-  return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text5, null, "Enter value for config ", /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, configName), ":"), /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, "> "), /* @__PURE__ */ React5.createElement(Text5, null, value), /* @__PURE__ */ React5.createElement(Text5, { color: "gray" }, "|")), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "(Press Enter to save, Esc to cancel)"));
+  return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text5, null, "Enter value for config ", /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, configName), defaultValue !== void 0 && /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, " (default: ", defaultValue, ")"), ":"), /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, "> "), /* @__PURE__ */ React5.createElement(Text5, null, value), /* @__PURE__ */ React5.createElement(Text5, { color: "gray" }, "|")), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, defaultValue !== void 0 ? "(Press Enter to accept default, type to override, Esc to cancel)" : "(Press Enter to save, Esc to cancel)"));
 }
 
 // src/commands/dev.tsx
@@ -191415,6 +191680,7 @@ function DevUI({ instanceKey, tunnelEnabled }) {
       const resourceStatus = /* @__PURE__ */ new Map();
       const syncDatabases = detectSyncDatabases(config2);
       let resources2;
+      let mailServers = /* @__PURE__ */ new Map();
       try {
         const result = await startResources({
           config: config2,
@@ -191462,6 +191728,7 @@ function DevUI({ instanceKey, tunnelEnabled }) {
         });
         if (result.cancelled) return;
         resources2 = result.resources;
+        mailServers = result.mail;
         startedResources.push(...result.startedResources);
       } catch (err) {
         const errorMsg = `Failed to start resources: ${err instanceof Error ? err.message : String(err)}`;
@@ -191856,6 +192123,9 @@ Add them to the config block in specific.local`);
         }
         const projectId = hasProjectId() ? readProjectId() : void 0;
         const hasTemporal = config2.temporal.length > 0;
+        const hasMail = config2.mail.length > 0;
+        const firstMailServer = mailServers.size > 0 ? [...mailServers.values()][0] : void 0;
+        const mailApiUrl = firstMailServer ? `http://127.0.0.1:${firstMailServer.apiPort}` : void 0;
         const getState = () => ({
           status: "running",
           services: config2.services.filter((svc) => runningServicePorts.has(svc.name) || svc.serve).map((svc) => ({
@@ -191872,7 +192142,9 @@ Add them to the config block in specific.local`);
             syncEnabled: r.type === "postgres" && syncDatabases.has(name)
           })),
           projectId,
-          hasTemporal
+          hasTemporal,
+          hasMail,
+          mailApiUrl
         });
         const adminServer = await startAdminServer(getState);
         adminServerRef.current = adminServer;
@@ -193506,6 +193778,7 @@ ${errorMsg}`
     {
       key: currentConfig,
       configName: currentConfig,
+      defaultValue: config.configs?.find((c) => c.name === currentConfig)?.default,
       onSubmit: handleConfigSubmit,
       onCancel: handleConfigCancel
     }
@@ -194307,11 +194580,226 @@ function betaCommand() {
   render8(/* @__PURE__ */ React10.createElement(BetaToggleUI, null));
 }
 
-// src/cli.tsx
+// src/commands/update.tsx
+import React11, { useState as useState10, useEffect as useEffect8 } from "react";
+import { render as render9, Text as Text11, Box as Box10, useApp as useApp6 } from "ink";
+import Spinner7 from "ink-spinner";
+
+// src/lib/update.ts
+import * as fs30 from "fs";
+import * as path28 from "path";
+var BINARIES_BASE_URL = "https://binaries.specific.dev/cli";
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  const len = Math.max(partsA.length, partsB.length);
+  for (let i = 0; i < len; i++) {
+    const numA = partsA[i] ?? 0;
+    const numB = partsB[i] ?? 0;
+    if (numA !== numB) return numA - numB;
+  }
+  return 0;
+}
+async function checkForUpdate() {
+  const currentVersion = "0.1.68";
+  const response = await fetch(`${BINARIES_BASE_URL}/latest`);
+  if (!response.ok) {
+    throw new Error(`Failed to check for updates: HTTP ${response.status}`);
+  }
+  const latestVersion = (await response.text()).trim();
+  const updateAvailable = compareVersions(latestVersion, currentVersion) > 0;
+  return { currentVersion, latestVersion, updateAvailable };
+}
+function getCurrentBinaryPath() {
+  return process.execPath;
+}
+function isBinaryWritable() {
+  const binaryPath = getCurrentBinaryPath();
+  const dir = path28.dirname(binaryPath);
+  try {
+    fs30.accessSync(dir, fs30.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function performUpdate(version, onProgress) {
+  const binaryPath = getCurrentBinaryPath();
+  const binaryDir = path28.dirname(binaryPath);
+  const tempPath = path28.join(binaryDir, `.specific-update-${process.pid}`);
+  try {
+    const { platform: platform5, arch: arch3 } = getPlatformInfo();
+    const url = `${BINARIES_BASE_URL}/${version}/specific-${platform5}-${arch3}`;
+    await downloadFile(url, tempPath, onProgress);
+    const stat4 = fs30.statSync(tempPath);
+    if (stat4.size === 0) {
+      throw new Error("Downloaded binary is empty");
+    }
+    fs30.chmodSync(tempPath, 493);
+    onProgress?.({ phase: "finalizing" });
+    fs30.unlinkSync(binaryPath);
+    fs30.renameSync(tempPath, binaryPath);
+  } catch (error) {
+    try {
+      if (fs30.existsSync(tempPath)) {
+        fs30.unlinkSync(tempPath);
+      }
+    } catch {
+    }
+    throw error;
+  }
+}
+
+// src/lib/background-update.ts
+import { spawn as spawn10 } from "child_process";
+import * as fs31 from "fs";
+import * as path29 from "path";
+import * as os9 from "os";
+var SPECIFIC_DIR = path29.join(os9.homedir(), ".specific");
+var RATE_LIMIT_FILE = path29.join(SPECIFIC_DIR, "last-update-check");
+var LOCK_FILE = path29.join(SPECIFIC_DIR, "update.lock");
+var RATE_LIMIT_MS = 60 * 60 * 1e3;
+var STALE_LOCK_MS = 10 * 60 * 1e3;
+function writeCheckTimestamp() {
+  fs31.mkdirSync(SPECIFIC_DIR, { recursive: true });
+  fs31.writeFileSync(RATE_LIMIT_FILE, String(Date.now()), "utf-8");
+}
+function isRateLimited() {
+  try {
+    const content = fs31.readFileSync(RATE_LIMIT_FILE, "utf-8").trim();
+    const lastCheck = parseInt(content, 10);
+    if (isNaN(lastCheck)) return false;
+    return Date.now() - lastCheck < RATE_LIMIT_MS;
+  } catch {
+    return false;
+  }
+}
+function maybeStartBackgroundUpdate() {
+  try {
+    if (true) return;
+    if (process.env.SPECIFIC_BACKGROUND_UPDATE === "1") return;
+    if (isRateLimited()) return;
+    if (!isBinaryWritable()) return;
+    const child = spawn10(process.execPath, [], {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        SPECIFIC_BACKGROUND_UPDATE: "1"
+      }
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+// src/commands/update.tsx
+function UpdateUI() {
+  const { exit } = useApp6();
+  const [state, setState] = useState10({ phase: "checking" });
+  useEffect8(() => {
+    if (state.phase !== "checking") return;
+    let cancelled = false;
+    async function check() {
+      try {
+        const result = await checkForUpdate();
+        if (cancelled) return;
+        if (!result.updateAvailable) {
+          setState({ phase: "up-to-date", checkResult: result });
+          return;
+        }
+        if (!isBinaryWritable()) {
+          setState({ phase: "permission-error", checkResult: result });
+          return;
+        }
+        setState({ phase: "downloading", checkResult: result });
+      } catch (err) {
+        if (cancelled) return;
+        setState({
+          phase: "error",
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    check();
+    return () => {
+      cancelled = true;
+    };
+  }, [state.phase]);
+  useEffect8(() => {
+    if (state.phase !== "downloading" || !state.checkResult) return;
+    let cancelled = false;
+    async function download() {
+      try {
+        await performUpdate(state.checkResult.latestVersion, (progress) => {
+          if (!cancelled) {
+            setState((s) => ({ ...s, progress }));
+          }
+        });
+        if (cancelled) return;
+        trackEvent("cli_updated", {
+          from_version: state.checkResult.currentVersion,
+          to_version: state.checkResult.latestVersion
+        });
+        writeCheckTimestamp();
+        setState((s) => ({ ...s, phase: "success" }));
+      } catch (err) {
+        if (cancelled) return;
+        setState({
+          phase: "error",
+          checkResult: state.checkResult,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    download();
+    return () => {
+      cancelled = true;
+    };
+  }, [state.phase, state.checkResult]);
+  useEffect8(() => {
+    if (state.phase === "up-to-date" || state.phase === "success" || state.phase === "error" || state.phase === "permission-error") {
+      const timer = setTimeout(() => exit(), 100);
+      return () => clearTimeout(timer);
+    }
+  }, [state.phase, exit]);
+  if (state.phase === "checking") {
+    return /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text11, { color: "blue" }, /* @__PURE__ */ React11.createElement(Spinner7, { type: "dots" })), /* @__PURE__ */ React11.createElement(Text11, null, " Checking for updates..."));
+  }
+  if (state.phase === "up-to-date") {
+    return /* @__PURE__ */ React11.createElement(Text11, { color: "green" }, "Already up to date (v", state.checkResult.currentVersion, ")");
+  }
+  if (state.phase === "permission-error") {
+    const { currentVersion, latestVersion } = state.checkResult;
+    return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column" }, /* @__PURE__ */ React11.createElement(Text11, null, "Update available: v", currentVersion, " \u2192 v", latestVersion), /* @__PURE__ */ React11.createElement(Text11, { color: "yellow" }, "Permission denied. Re-run with sudo:"), /* @__PURE__ */ React11.createElement(Text11, { color: "cyan" }, " sudo specific update"));
+  }
+  if (state.phase === "downloading") {
+    const { currentVersion, latestVersion } = state.checkResult;
+    const { progress } = state;
+    const progressText = progress?.percent ? ` (${progress.percent}%)` : "";
+    return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column" }, /* @__PURE__ */ React11.createElement(Text11, null, "Updating: v", currentVersion, " \u2192 v", latestVersion), /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text11, { color: "blue" }, /* @__PURE__ */ React11.createElement(Spinner7, { type: "dots" })), /* @__PURE__ */ React11.createElement(Text11, null, " ", progress?.phase === "finalizing" ? "Installing..." : `Downloading${progressText}`)));
+  }
+  if (state.phase === "success") {
+    const { currentVersion, latestVersion } = state.checkResult;
+    return /* @__PURE__ */ React11.createElement(Text11, { color: "green" }, "Updated successfully: v", currentVersion, " \u2192 v", latestVersion);
+  }
+  return /* @__PURE__ */ React11.createElement(Text11, { color: "red" }, "Update failed: ", state.error);
+}
+function updateCommand() {
+  const distribution = "npm";
+  if (distribution !== "binary") {
+    console.log("This installation was installed via npm.");
+    console.log("To update, run: npm update -g @specific.dev/cli");
+    return;
+  }
+  render9(/* @__PURE__ */ React11.createElement(UpdateUI, null));
+}
+
+// src/cli-program.tsx
 var program = new Command();
 var env = "production";
 var envLabel = env !== "production" ? `[${env.toUpperCase()}] ` : "";
-program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.66").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.68").enablePositionalOptions();
 program.command("init").description("Initialize project for use with a coding agent").option("--agent <name...>", "Agents to configure (cursor, claude, codex, other)").action((options2) => initCommand(options2));
 program.command("docs [topic]").description("Fetch LLM-optimized documentation").action(docsCommand);
 program.command("check").description("Validate specific.hcl configuration").action(checkCommand);
@@ -194340,13 +194828,17 @@ program.command("clean").description("Remove .specific directory for a clean sla
   cleanCommand(options2.key);
 });
 program.command("beta").description("Manage beta feature flags").action(betaCommand);
+program.command("update").description("Update Specific CLI to the latest version").action(updateCommand);
 program.command("login").description("Log in to Specific").action(loginCommand);
 program.command("logout").description("Log out of Specific").action(logoutCommand);
 var commandName = process.argv[2] || "help";
 trackEvent("cli_command_invoked", { command: commandName });
+maybeStartBackgroundUpdate();
 process.on("beforeExit", async () => {
   await shutdown();
 });
+
+// src/cli.tsx
 program.parse();
 /*! Bundled license information: