@brownie-labs/brownie 0.1.0 → 0.3.0

package/README.md

@@ -121,20 +121,21 @@ Configuration commands persist to `.brownie/settings.json` and apply live — th
 
 Without a TTY (systemd, Docker, CI, piping) brownie skips the dashboard, starts the agents immediately, and prints structured line logs to stdout — human-readable by default, NDJSON with `--log-format json` for log aggregators. A running worker is controlled from a second shell over a local control socket:
 
-| Command                                                   | Effect                                                        |
-| --------------------------------------------------------- | ------------------------------------------------------------- |
-| `brownie`                                                 | start the worker (TUI in a terminal, headless without one)    |
-| `brownie --headless [--log-format json]`                  | force headless mode even in a terminal                        |
-| `brownie init --monitor-prompt <f> --executor-prompt <f>` | non-interactive setup for servers (cloud-init, Ansible)       |
-| `brownie status [--json]`                                 | live status of the running worker (doubles as a health check) |
-| `brownie pause [monitor\|executor]`                       | graceful pause, same as `/pause` in the TUI                   |
-| `brownie resume [monitor\|executor]`                      | resume paused agents                                          |
+| Command                                                   | Effect                                                                      |
+| --------------------------------------------------------- | --------------------------------------------------------------------------- |
+| `brownie`                                                 | start the worker (TUI in a terminal, headless without one)                  |
+| `brownie --headless [--log-format json]`                  | force headless mode even in a terminal                                      |
+| `brownie init --monitor-prompt <f> --executor-prompt <f>` | non-interactive setup for servers (cloud-init, Ansible)                     |
+| `brownie status [--json]`                                 | live status of the running worker (doubles as a health check)               |
+| `brownie pause [monitor\|executor]`                       | graceful pause, same as `/pause` in the TUI                                 |
+| `brownie resume [monitor\|executor]`                      | resume paused agents                                                        |
+| `brownie update [--check]`                                | update to the newest published version (auto-updates in the background too) |
 
 A second `brownie` in the same project refuses to start while one is already running. The full server story — the NDJSON event schema, a DigitalOcean/systemd runbook, authentication without a browser, and the reference `Dockerfile` + `docker-compose.yml`: [docs/deployment.md](https://github.com/brownie-labs/brownie/blob/main/docs/deployment.md).
 
 ## Configuration
 
-Like Claude Code's `.claude/`, all per-project state lives in `.brownie/` inside the directory you run brownie from: `settings.json`, the two project prompts, and runtime data (tasks, memory, logs — gitignored automatically). The settings file is a zod-validated JSON where every section is optional — change it with the slash commands above or by hand:
+Like Claude Code's `.claude/`, all per-project state lives in `.brownie/` inside the directory you run brownie from: `settings.json`, the two project prompts, and runtime data (tasks, memory, logs — gitignored automatically). The settings file is a strictly validated JSON where every section is optional — change it with the slash commands above or by hand:
 
 ```json
 {

package/dist/index.js

@@ -171,11 +171,12 @@ var logger = createConsola({
 // src/paths.ts
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
 var BROWNIE_DIR_NAME = ".brownie";
+var FALLBACK_PACKAGE_NAME = "@brownie-labs/brownie";
 function projectPaths(projectDir = process.cwd()) {
   const brownieDir = join(projectDir, BROWNIE_DIR_NAME);
   const promptsDir = join(brownieDir, "prompts");
@@ -202,15 +203,26 @@ function controlSocketPath(projectDir = process.cwd()) {
 }
 var packageRootDir = dirname(dirname(fileURLToPath(import.meta.url)));
 var packagePromptsDir = join(packageRootDir, "prompts");
-var packageManifestSchema = z.object({ version: z.string() });
-function packageVersion() {
+var globalBrownieDir = join(homedir(), BROWNIE_DIR_NAME);
+var globalConfigFile = join(globalBrownieDir, "config.json");
+var packageManifestSchema = z.object({
+  name: z.string().default(FALLBACK_PACKAGE_NAME),
+  version: z.string().default("unknown")
+});
+function readPackageManifest() {
   try {
     const raw = readFileSync(join(packageRootDir, "package.json"), "utf8");
-    return packageManifestSchema.parse(JSON.parse(raw)).version;
+    return packageManifestSchema.parse(JSON.parse(raw));
   } catch {
-    return "unknown";
+    return { name: FALLBACK_PACKAGE_NAME, version: "unknown" };
   }
 }
+function packageVersion() {
+  return readPackageManifest().version;
+}
+function packageName() {
+  return readPackageManifest().name;
+}
 function systemPromptFiles(dir = packagePromptsDir) {
   return {
     monitor: join(dir, "monitor.system.md"),
@@ -2071,6 +2083,31 @@ async function runExecutorLoop(config, store, waker, reporter, summarizer, contr
   }
 }
 
+// src/global-config.ts
+import { readFile as readFile5 } from "node:fs/promises";
+import { z as z5 } from "zod";
+var globalConfigSchema = z5.object({
+  autoUpdate: z5.boolean().default(true)
+}).strict();
+var DEFAULT_GLOBAL_CONFIG = globalConfigSchema.parse({});
+async function loadGlobalConfig(file = globalConfigFile) {
+  let raw;
+  try {
+    raw = await readFile5(file, "utf8");
+  } catch {
+    return DEFAULT_GLOBAL_CONFIG;
+  }
+  try {
+    return globalConfigSchema.parse(JSON.parse(raw));
+  } catch {
+    return DEFAULT_GLOBAL_CONFIG;
+  }
+}
+function isAutoUpdaterDisabled(env = process.env) {
+  const value = env.BROWNIE_DISABLE_AUTOUPDATER?.trim().toLowerCase();
+  return value === "1" || value === "true";
+}
+
 // src/headless/events.ts
 function compactFields(fields) {
   const compacted = {};
@@ -2316,13 +2353,13 @@ function teeReporter(primary, secondary) {
 }
 
 // src/memory/summarizer.ts
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 
 // src/memory/summary.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/report.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var TASK_REPORT_JSON_SCHEMA = JSON.stringify({
   type: "object",
   properties: {
@@ -2350,12 +2387,12 @@ var TASK_REPORT_JSON_SCHEMA = JSON.stringify({
   required: ["tasks"],
   additionalProperties: false
 });
-var taskReportSchema = z5.object({
-  tasks: z5.array(
-    z5.object({
-      id: z5.string().trim().min(1),
-      title: z5.string().trim().min(1),
-      description: z5.string().trim().default("")
+var taskReportSchema = z6.object({
+  tasks: z6.array(
+    z6.object({
+      id: z6.string().trim().min(1),
+      title: z6.string().trim().min(1),
+      description: z6.string().trim().default("")
     })
   )
 });
@@ -2446,9 +2483,9 @@ var SUMMARY_JSON_SCHEMA = JSON.stringify({
   required: ["headline", "summary"],
   additionalProperties: false
 });
-var summarySchema = z6.object({
-  headline: z6.string().trim().min(1),
-  summary: z6.string().trim().min(1)
+var summarySchema = z7.object({
+  headline: z7.string().trim().min(1),
+  summary: z7.string().trim().min(1)
 });
 function parseSummary(resultText) {
   const candidate = lastJsonBlock(resultText) ?? resultText.trim();
@@ -2526,7 +2563,7 @@ var SessionSummarizer = class {
         finished(false, "executor session log file not found");
         return;
       }
-      const systemPrompt = await readFile5(summarizer.systemPromptPath, "utf8");
+      const systemPrompt = await readFile6(summarizer.systemPromptPath, "utf8");
       const sessionResult = await runSession(
         {
           command: this.deps.command,
@@ -2582,7 +2619,7 @@ var SessionSummarizer = class {
 };
 
 // src/monitor.ts
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 async function runMonitorLoop(config, store, waker, reporter, controller, limitGate, signal) {
   const { monitor } = config;
   const aborted = () => signal.aborted;
@@ -2608,8 +2645,8 @@ async function runMonitorLoop(config, store, waker, reporter, controller, limitG
     reporter.cycleStarted(cycle);
     try {
       const [prompt, systemPrompt] = await Promise.all([
-        readFile6(monitor.promptPath, "utf8"),
-        readFile6(monitor.systemPromptPath, "utf8")
+        readFile7(monitor.promptPath, "utf8"),
+        readFile7(monitor.systemPromptPath, "utf8")
       ]);
       const result = await runSession(
         {
@@ -2778,11 +2815,11 @@ ${details}`);
 }
 
 // src/prompt-files.ts
-import { readFile as readFile7, rename, writeFile as writeFile2 } from "node:fs/promises";
+import { readFile as readFile8, rename, writeFile as writeFile2 } from "node:fs/promises";
 var PROMPT_AGENTS = ["monitor", "executor"];
 function createPromptFileAccess(paths) {
   return {
-    read: async (agent) => (await readFile7(paths[agent], "utf8")).trimEnd(),
+    read: async (agent) => (await readFile8(paths[agent], "utf8")).trimEnd(),
     write: async (agent, content) => {
       const path = paths[agent];
       const tmpPath = `${path}.tmp`;
@@ -2868,11 +2905,11 @@ function teeSession(reporter, extra) {
 }
 
 // src/settings-file.ts
-import { readFile as readFile8, rename as rename2, writeFile as writeFile3 } from "node:fs/promises";
+import { readFile as readFile9, rename as rename2, writeFile as writeFile3 } from "node:fs/promises";
 async function readRawSettings(settingsFile) {
   let raw;
   try {
-    raw = await readFile8(settingsFile, "utf8");
+    raw = await readFile9(settingsFile, "utf8");
   } catch (err) {
     throw new Error(
       `settings file missing: ${settingsFile} \u2014 run brownie in an interactive terminal to complete setup`,
@@ -3044,6 +3081,7 @@ var WorkerStatusStore = class {
   listeners = /* @__PURE__ */ new Set();
   notifyTimer = null;
   shutdownSignal;
+  updateStatus;
   tasks = [];
   snapshot;
   stats = {
@@ -3176,6 +3214,10 @@ var WorkerStatusStore = class {
     this.shutdownSignal = signalName;
     this.markDirty();
   }
+  setUpdateStatus(info) {
+    this.updateStatus = info;
+    this.markDirty();
+  }
   subscribe = (listener) => {
     this.listeners.add(listener);
     return () => {
@@ -3321,7 +3363,8 @@ var WorkerStatusStore = class {
       monitor: this.buildPanel(this.monitorState),
       executor: this.buildPanel(this.executorState),
       tasks: this.tasks,
-      stats: { ...this.stats }
+      stats: { ...this.stats },
+      update: this.updateStatus
     };
   }
   buildPanel(state) {
@@ -3346,22 +3389,22 @@ var WorkerStatusStore = class {
 };
 
 // src/tasks.ts
-import { mkdir as mkdir2, readFile as readFile9, rename as rename3, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile10, rename as rename3, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname3 } from "node:path";
-import { z as z7 } from "zod";
-var taskSchema = z7.object({
-  id: z7.string().min(1),
-  title: z7.string(),
-  description: z7.string(),
-  status: z7.enum(["pending", "in_progress", "done", "failed", "cancelled"]),
-  attempts: z7.number().int().nonnegative().default(0),
-  createdAt: z7.string(),
-  updatedAt: z7.string(),
-  error: z7.string().optional()
+import { z as z8 } from "zod";
+var taskSchema = z8.object({
+  id: z8.string().min(1),
+  title: z8.string(),
+  description: z8.string(),
+  status: z8.enum(["pending", "in_progress", "done", "failed", "cancelled"]),
+  attempts: z8.number().int().nonnegative().default(0),
+  createdAt: z8.string(),
+  updatedAt: z8.string(),
+  error: z8.string().optional()
 });
-var storeFileSchema = z7.object({
-  version: z7.literal(1),
-  tasks: z7.array(taskSchema)
+var storeFileSchema = z8.object({
+  version: z8.literal(1),
+  tasks: z8.array(taskSchema)
 });
 function corruptStoreError(path, reason) {
   return new Error(
@@ -3382,7 +3425,7 @@ var TaskStore = class _TaskStore {
     await mkdir2(dirname3(path), { recursive: true });
     let raw;
     try {
-      raw = await readFile9(path, "utf8");
+      raw = await readFile10(path, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
@@ -3543,6 +3586,245 @@ var TaskStore = class _TaskStore {
   }
 };
 
+// src/update/version.ts
+var SEMVER_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseVersion(raw) {
+  const match = SEMVER_PATTERN.exec(raw.trim());
+  if (match === null) return null;
+  const [, major, minor, patch, prerelease] = match;
+  return {
+    major: Number(major),
+    minor: Number(minor),
+    patch: Number(patch),
+    prerelease: prerelease ?? null
+  };
+}
+function comparePrerelease(a, b) {
+  if (a === b) return 0;
+  if (a === null) return 1;
+  if (b === null) return -1;
+  const aParts = a.split(".");
+  const bParts = b.split(".");
+  for (let i = 0; i < Math.max(aParts.length, bParts.length); i += 1) {
+    const aPart = aParts[i];
+    const bPart = bParts[i];
+    if (aPart === void 0) return -1;
+    if (bPart === void 0) return 1;
+    const aNum = Number(aPart);
+    const bNum = Number(bPart);
+    const aIsNum = Number.isInteger(aNum);
+    const bIsNum = Number.isInteger(bNum);
+    if (aIsNum && bIsNum) {
+      if (aNum !== bNum) return aNum < bNum ? -1 : 1;
+    } else if (aIsNum !== bIsNum) {
+      return aIsNum ? -1 : 1;
+    } else if (aPart !== bPart) {
+      return aPart < bPart ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function compareVersions(a, b) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key]) return a[key] < b[key] ? -1 : 1;
+  }
+  return comparePrerelease(a.prerelease, b.prerelease);
+}
+function isNewer(current, latest) {
+  const currentVersion = parseVersion(current);
+  const latestVersion = parseVersion(latest);
+  if (currentVersion === null || latestVersion === null) return false;
+  return compareVersions(currentVersion, latestVersion) < 0;
+}
+
+// src/update/auto-update.ts
+var UPDATE_CHECK_INTERVAL_MS = 30 * 6e4;
+async function runAutoUpdateLoop(options) {
+  const {
+    globalConfig,
+    deps,
+    setUpdateStatus,
+    emit,
+    signal,
+    intervalMs = UPDATE_CHECK_INTERVAL_MS,
+    initialDelayMs = 0,
+    env = process.env
+  } = options;
+  if (isAutoUpdaterDisabled(env)) return;
+  const method = deps.detect();
+  if (method === "unknown") return;
+  if (initialDelayMs > 0) await sleep(initialDelayMs, signal);
+  let lastActioned;
+  while (!signal.aborted) {
+    try {
+      const latest = await deps.fetchLatest(deps.name);
+      if (latest !== null && latest !== lastActioned && isNewer(deps.current, latest)) {
+        lastActioned = latest;
+        await handleNewVersion({
+          globalConfig,
+          deps,
+          method,
+          latest,
+          setUpdateStatus,
+          emit
+        });
+      }
+    } catch {
+    }
+    await sleep(intervalMs, signal);
+  }
+}
+async function handleNewVersion(args) {
+  const { globalConfig, deps, method, latest, setUpdateStatus, emit } = args;
+  const from = deps.current;
+  if (!globalConfig.autoUpdate) {
+    setUpdateStatus({ state: "available", from, to: latest });
+    emit?.({
+      level: "info",
+      event: "update.available",
+      fields: { from, to: latest }
+    });
+    return;
+  }
+  const result = await deps.install(method, deps.name);
+  if (result.ok) {
+    setUpdateStatus({ state: "installed", from, to: latest });
+    emit?.({
+      level: "info",
+      event: "update.installed",
+      fields: { from, to: latest }
+    });
+    return;
+  }
+  setUpdateStatus({ state: "available", from, to: latest, installError: result.output });
+  emit?.({
+    level: "warn",
+    event: "update.available",
+    fields: { from, to: latest, installError: result.output }
+  });
+}
+
+// src/update/install.ts
+import { spawn as spawn2 } from "node:child_process";
+var KILL_GRACE_MS2 = 5e3;
+var DEFAULT_INSTALL_TIMEOUT_MS = 12e4;
+function detectInstallMethod(rootDir = packageRootDir) {
+  const normalized = rootDir.replaceAll("\\", "/").toLowerCase();
+  if (!normalized.includes("/node_modules/") && !normalized.endsWith("/node_modules")) {
+    return "unknown";
+  }
+  if (normalized.includes("/pnpm/") || normalized.includes("/.pnpm/")) return "pnpm";
+  if (normalized.includes("/yarn/") || normalized.includes("/.yarn/")) return "yarn";
+  if (normalized.includes("/.bun/") || normalized.includes("/bun/")) return "bun";
+  return "npm";
+}
+function installCommand(method, name) {
+  const target = `${name}@latest`;
+  switch (method) {
+    case "npm":
+      return { command: "npm", args: ["install", "-g", target] };
+    case "pnpm":
+      return { command: "pnpm", args: ["add", "-g", target] };
+    case "yarn":
+      return { command: "yarn", args: ["global", "add", target] };
+    case "bun":
+      return { command: "bun", args: ["add", "-g", target] };
+  }
+}
+function runInstall(method, name, options = {}) {
+  const { command, args } = installCommand(method, name);
+  const { env = process.env, timeoutMs = DEFAULT_INSTALL_TIMEOUT_MS } = options;
+  return new Promise((resolvePromise) => {
+    const child = spawn2(command, args, { env, stdio: ["ignore", "pipe", "pipe"] });
+    const chunks = [];
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolvePromise(result);
+    };
+    const timer = setTimeout(() => {
+      chunks.push(`
+Install timed out after ${String(timeoutMs)}ms`);
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS2).unref();
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => chunks.push(chunk.toString()));
+    child.stderr.on("data", (chunk) => chunks.push(chunk.toString()));
+    child.on("error", (err) => {
+      chunks.push(`Failed to start "${command}": ${err.message}`);
+      settle({ ok: false, output: chunks.join("").trim() });
+    });
+    child.on("close", (code) => {
+      settle({ ok: code === 0, output: chunks.join("").trim() });
+    });
+  });
+}
+
+// src/update/registry.ts
+import { z as z9 } from "zod";
+var REGISTRY_BASE_URL = "https://registry.npmjs.org";
+var DEFAULT_TIMEOUT_MS = 5e3;
+var distTagSchema = z9.object({ version: z9.string() });
+async function fetchLatestVersion(name, options = {}) {
+  const {
+    fetchImpl = fetch,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    registryBaseUrl = REGISTRY_BASE_URL
+  } = options;
+  const url = `${registryBaseUrl}/${name}/latest`;
+  try {
+    const response = await fetchImpl(url, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!response.ok) return null;
+    const parsed = distTagSchema.safeParse(await response.json());
+    return parsed.success ? parsed.data.version : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/update/updater.ts
+function defaultUpdateDeps(overrides = {}) {
+  return {
+    name: packageName(),
+    current: packageVersion(),
+    fetchLatest: (name) => fetchLatestVersion(name),
+    detect: () => detectInstallMethod(),
+    install: (method, name) => runInstall(method, name),
+    ...overrides
+  };
+}
+async function checkForUpdate(deps) {
+  const latest = await deps.fetchLatest(deps.name);
+  return {
+    current: deps.current,
+    latest,
+    newer: latest !== null && isNewer(deps.current, latest),
+    method: deps.detect()
+  };
+}
+async function performUpdate(deps, options) {
+  const check2 = await checkForUpdate(deps);
+  const base = { from: check2.current, method: check2.method };
+  if (check2.latest === null) return { ...base, status: "unreachable" };
+  if (!check2.newer) return { ...base, status: "up-to-date", to: check2.latest };
+  if (!options.install) return { ...base, status: "available", to: check2.latest };
+  if (check2.method === "unknown") {
+    return { ...base, status: "unmanaged", to: check2.latest };
+  }
+  const result = await deps.install(check2.method, deps.name);
+  return {
+    ...base,
+    status: result.ok ? "updated" : "failed",
+    to: check2.latest,
+    output: result.output
+  };
+}
+
 // src/ui/mount.tsx
 import { render as render2 } from "ink";
 
@@ -4101,11 +4383,11 @@ async function dispatchCommand(line, ctx) {
 }
 
 // src/ui/header.tsx
-import { homedir } from "node:os";
+import { homedir as homedir2 } from "node:os";
 import { Box as Box5, Text as Text5 } from "ink";
 import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 function shortenPath(path) {
-  const home = homedir();
+  const home = homedir2();
   return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
 }
 function HeaderLine({ left, right }) {
@@ -4155,7 +4437,8 @@ function Header({ config, version, status, now }) {
             right: `${config.executor.model} \xB7 ${config.executor.effort}`
           }
         ),
-        /* @__PURE__ */ jsx6(Text5, { dimColor: true, wrap: "truncate-end", children: formatHeaderStats(status.stats, status.tasks, now - status.startedAt) })
+        /* @__PURE__ */ jsx6(Text5, { dimColor: true, wrap: "truncate-end", children: formatHeaderStats(status.stats, status.tasks, now - status.startedAt) }),
+        status.update === void 0 ? null : /* @__PURE__ */ jsx6(Text5, { color: theme.accent, wrap: "truncate-end", children: status.update.state === "installed" ? `\u2B06 updated to v${status.update.to} \u2014 restart to apply` : `\u2B06 update available v${status.update.from} \u2192 v${status.update.to} \u2014 run "brownie update"` })
       ]
     }
   );
@@ -4931,9 +5214,10 @@ function App({
   const inputHeight = interactive && !editing ? INPUT_HEIGHT : 0;
   const menuHeight = menuOpen ? Math.min(suggestionList.length, SUGGESTION_WINDOW) : 0;
   const shutdownHeight = status.shutdownSignal === void 0 ? 0 : 1;
+  const headerHeight = HEADER_HEIGHT + (status.update === void 0 ? 0 : 1);
   const contentHeight = Math.max(
     6,
-    rows - HEADER_HEIGHT - inputHeight - menuHeight - hintHeight - noticeHeight - shutdownHeight
+    rows - headerHeight - inputHeight - menuHeight - hintHeight - noticeHeight - shutdownHeight
   );
   const scrollTarget = view.kind === "dashboard" ? focusedPanel : view.kind === "monitor" || view.kind === "executor" ? view.kind : null;
   useInput2(
@@ -5302,6 +5586,7 @@ async function startWorker(options = {}) {
       projectDir: config.cwd
     }
   });
+  const globalConfig = await loadGlobalConfig();
   let loopError;
   try {
     await Promise.all([
@@ -5323,7 +5608,14 @@ async function startWorker(options = {}) {
         executorControl,
         limitGate,
         signal
-      )
+      ),
+      runAutoUpdateLoop({
+        globalConfig,
+        deps: defaultUpdateDeps(),
+        setUpdateStatus: (info) => status.setUpdateStatus(info),
+        emit: headlessEmit,
+        signal
+      })
     ]);
   } catch (err) {
     loopError = err;
@@ -5354,7 +5646,7 @@ async function runBrownie(options = {}) {
   const [positional] = options.positionals ?? [];
   if (positional !== void 0) {
     logger.error(
-      `Unknown command "${positional}" \u2014 available commands: init, status, pause, resume, mcp; run plain brownie to start the worker.`
+      `Unknown command "${positional}" \u2014 available commands: init, status, pause, resume, update, mcp; run plain brownie to start the worker.`
     );
     process.exitCode = 1;
     return;
@@ -5415,6 +5707,72 @@ var mcpCommand = defineCommand5({
   }
 });
 
+// src/update-command.ts
+import { defineCommand as defineCommand6 } from "citty";
+async function runUpdate(options = {}) {
+  const deps = options.deps ?? defaultUpdateDeps();
+  const install = options.check !== true;
+  const outcome = await performUpdate(deps, { install });
+  switch (outcome.status) {
+    case "unreachable":
+      logger.error("Could not reach the npm registry to check for updates.");
+      process.exitCode = 1;
+      break;
+    case "up-to-date":
+      logger.success(`brownie is up to date (${outcome.from}).`);
+      break;
+    case "available":
+      logger.info(`Update available: ${outcome.from} \u2192 ${outcome.to ?? "?"}.`);
+      logger.info('Run "brownie update" to install it.');
+      break;
+    case "unmanaged": {
+      const manual = installCommand("npm", deps.name);
+      logger.warn(
+        `Update available: ${outcome.from} \u2192 ${outcome.to ?? "?"}, but the install location is not a global package manager install. Install it manually:`
+      );
+      logger.info(`  ${manual.command} ${manual.args.join(" ")}`);
+      process.exitCode = 1;
+      break;
+    }
+    case "updated":
+      logger.success(
+        `Updated brownie ${outcome.from} \u2192 ${outcome.to ?? "?"}. Restart to apply.`
+      );
+      break;
+    case "failed":
+      logger.error(
+        `Failed to update brownie ${outcome.from} \u2192 ${outcome.to ?? "?"} via ${outcome.method}.`
+      );
+      if (outcome.output) logger.error(outcome.output);
+      process.exitCode = 1;
+      break;
+  }
+  await reportAutoUpdateState();
+}
+async function reportAutoUpdateState() {
+  if (isAutoUpdaterDisabled()) {
+    logger.info("Auto-update is disabled (BROWNIE_DISABLE_AUTOUPDATER).");
+    return;
+  }
+  const config = await loadGlobalConfig();
+  logger.info(
+    `Auto-update is ${config.autoUpdate ? "on" : "off (notify only)"} \u2014 configure it in ${globalConfigFile}.`
+  );
+}
+var updateCommand = defineCommand6({
+  meta: {
+    name: "update",
+    description: "Check npm for a newer brownie and install it."
+  },
+  args: {
+    check: {
+      type: "boolean",
+      description: "Only check for a newer version without installing it"
+    }
+  },
+  run: ({ args }) => runUpdate({ check: args.check })
+});
+
 // src/index.ts
 var rawArgs = process.argv.slice(2);
 var [first, ...rest] = rawArgs;
@@ -5434,6 +5792,9 @@ switch (first) {
   case "resume":
     void runMain(resumeCommand, { rawArgs: rest });
     break;
+  case "update":
+    void runMain(updateCommand, { rawArgs: rest });
+    break;
   default:
     void runMain(mainCommand, { rawArgs });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brownie-labs/brownie",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Autonomous two-agent Claude Code worker: a monitor that finds tasks, an executor that completes them, and long-term memory in between",
   "type": "module",
   "license": "MIT",