@devstationlabs/cli 0.1.2 → 0.1.4

package/README.md

@@ -46,6 +46,15 @@ devstation config              # what it will use, and where each value came fro
 Exporting `ANTHROPIC_API_KEY` or `OPENROUTER_API_KEY` still works, and is what a
 server or CI job should do.
 
+## Upgrade
+
+```sh
+devstation upgrade
+```
+
+It upgrades however it was installed: through npm for an npm install, or by
+downloading and verifying the new binary for the standalone one.
+
 ## Use it
 
 ```sh

package/devstation.js

@@ -12510,7 +12510,7 @@ import { existsSync as existsSync12 } from "fs";
 
 // src/lib/agent/cli/args.ts
 var CLI_NAME = "devstation";
-var VERSION = "0.1.2";
+var VERSION = "0.1.4";
 var COMMANDS = new Set([
   "chat",
   "run",
@@ -12528,6 +12528,7 @@ var COMMANDS = new Set([
   "config",
   "login",
   "logout",
+  "upgrade",
   "doctor",
   "version",
   "help"
@@ -12542,6 +12543,7 @@ var OFFLINE_COMMANDS = new Set([
   "config",
   "login",
   "logout",
+  "upgrade",
   "doctor",
   "version",
   "help",
@@ -12558,6 +12560,7 @@ function parseArgs(argv, cwd = process.cwd()) {
     json: false,
     sandbox: (process.env.DEVSTATION_SANDBOX ?? "").toLowerCase() !== "off",
     project: false,
+    check: false,
     root: cwd
   };
   const words = [];
@@ -12585,6 +12588,9 @@ function parseArgs(argv, cwd = process.cwd()) {
       case "--project":
         parsed.project = true;
         break;
+      case "--check":
+        parsed.check = true;
+        break;
       case "-h":
       case "--help":
         parsed.command = "help";
@@ -12675,6 +12681,7 @@ var HELP = `DevStation, the coding agent.
   ${CLI_NAME} tools                list the tools it can use, and which ones ask first
   ${CLI_NAME} login [provider]     store an API key and choose a model
   ${CLI_NAME} logout [provider]    remove stored API keys
+  ${CLI_NAME} upgrade [--check]    update to the latest version (--check only reports)
   ${CLI_NAME} config               show the settings a run would use, and where each came from
   ${CLI_NAME} config set <key> <value> [--project]
                                set provider, model or baseUrl
@@ -12696,6 +12703,7 @@ Options
   --json              JSON from config, sessions, checkpoints and tools
   --no-sandbox        run commands on this machine instead of in a container
   --project           with config set/unset: write this workspace's config, not the global one
+  --check             with upgrade: say whether a newer version exists, change nothing
   -h, --help          this
   -v, --version       the version
 
@@ -12723,7 +12731,7 @@ var SESSION_HELP = `  /undo          rewind the last checkpoint
 import { accessSync, constants as constants2, existsSync as existsSync10 } from "fs";
 
 // src/lib/agent/git.ts
-import { existsSync } from "fs";
+import { existsSync, readFileSync, statSync } from "fs";
 import { join } from "path";
 
 // src/lib/agent/shell.ts
@@ -12941,7 +12949,16 @@ function cloneTargetProblem(target) {
 // src/lib/agent/git.ts
 var CHECKPOINT_PREFIX = "agent checkpoint:";
 function isRepo(root) {
-  return existsSync(join(root, ".git"));
+  const dotGit = join(root, ".git");
+  if (!existsSync(dotGit))
+    return false;
+  try {
+    if (statSync(dotGit).isFile())
+      return readFileSync(dotGit, "utf8").startsWith("gitdir:");
+  } catch {
+    return false;
+  }
+  return existsSync(join(dotGit, "HEAD"));
 }
 function quote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -13066,7 +13083,7 @@ import {
   cpSync,
   existsSync as existsSync3,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   readdirSync as readdirSync2,
   rmSync,
   writeFileSync as writeFileSync2
@@ -13077,10 +13094,10 @@ import { dirname as dirname2, join as join3 } from "path";
 import {
   existsSync as existsSync2,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   readdirSync,
   realpathSync,
-  statSync,
+  statSync as statSync2,
   writeFileSync
 } from "fs";
 import { dirname, isAbsolute, join as join2, relative, resolve, sep } from "path";
@@ -13157,10 +13174,10 @@ class Workspace {
     if (!existsSync2(resolved.absolute)) {
       return { ok: false, reason: `There is no file at ${relativePath}.` };
     }
-    if (statSync(resolved.absolute).isDirectory()) {
+    if (statSync2(resolved.absolute).isDirectory()) {
       return { ok: false, reason: `${relativePath} is a directory, not a file.` };
     }
-    const buffer = readFileSync(resolved.absolute);
+    const buffer = readFileSync2(resolved.absolute);
     if (looksBinary(buffer)) {
       return {
         ok: false,
@@ -13180,10 +13197,10 @@ class Workspace {
     if (!resolved.ok)
       return { ok: false, reason: resolved.reason };
     if (existsSync2(resolved.absolute)) {
-      if (statSync(resolved.absolute).isDirectory()) {
+      if (statSync2(resolved.absolute).isDirectory()) {
         return { ok: false, reason: `${relativePath} is a directory.` };
       }
-      if (looksBinary(readFileSync(resolved.absolute))) {
+      if (looksBinary(readFileSync2(resolved.absolute))) {
         return { ok: false, reason: `${relativePath} is a binary file and was not overwritten.` };
       }
     }
@@ -13195,7 +13212,7 @@ class Workspace {
     const resolved = this.resolve(relativePath);
     return resolved.ok && existsSync2(resolved.absolute);
   }
-  list(subdir = ".") {
+  list(subdir = ".", limit = Number.POSITIVE_INFINITY) {
     const base = subdir === "." || subdir === "" ? { ok: true, absolute: this.root } : this.resolve(subdir);
     if (!base.ok || !existsSync2(base.absolute))
       return [];
@@ -13204,6 +13221,8 @@ class Workspace {
     const out = [];
     const walk = (dir) => {
       for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (out.length >= limit)
+          return;
         if (entry.name.startsWith(".") && skip.has(entry.name))
           continue;
         if (skip.has(entry.name))
@@ -13236,7 +13255,7 @@ function listSnapshots(root) {
     if (!existsSync3(manifest))
       continue;
     try {
-      found.push(JSON.parse(readFileSync2(manifest, "utf8")));
+      found.push(JSON.parse(readFileSync3(manifest, "utf8")));
     } catch {}
   }
   return found.sort((a, b) => b.id.localeCompare(a.id));
@@ -18114,9 +18133,9 @@ import {
   chmodSync,
   existsSync as existsSync4,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   renameSync,
-  statSync as statSync2,
+  statSync as statSync3,
   writeFileSync as writeFileSync3
 } from "fs";
 import { dirname as dirname4, join as join5 } from "path";
@@ -18151,11 +18170,12 @@ function readSettingsFile(path4, problems = []) {
   if (!existsSync4(path4))
     return {};
   try {
-    const raw = JSON.parse(readFileSync3(path4, "utf8"));
+    const raw = JSON.parse(readFileSync4(path4, "utf8"));
     const out = {};
     if (raw.provider !== undefined) {
-      if (isProvider(raw.provider))
-        out.provider = raw.provider;
+      const named = typeof raw.provider === "string" ? raw.provider.toLowerCase() : raw.provider;
+      if (isProvider(named))
+        out.provider = named;
       else
         problems.push(`${path4}: unknown provider "${String(raw.provider)}".`);
     }
@@ -18195,11 +18215,11 @@ function readCredentials(home, problems = []) {
   if (!existsSync4(path4))
     return {};
   try {
-    const mode = statSync2(path4).mode & 511;
+    const mode = statSync3(path4).mode & 511;
     if (mode & 63) {
       problems.push(`${path4} is readable by other users (mode ${mode.toString(8)}). Fix it: chmod 600 ${path4}`);
     }
-    const raw = JSON.parse(readFileSync3(path4, "utf8"));
+    const raw = JSON.parse(readFileSync4(path4, "utf8"));
     const out = {};
     for (const id of PROVIDER_IDS) {
       if (typeof raw[id] === "string" && raw[id].trim())
@@ -18228,8 +18248,9 @@ function resolveSettings(opts) {
   let provider = null;
   let providerSource = "not set";
   if (env2.DEVSTATION_PROVIDER) {
-    if (isProvider(env2.DEVSTATION_PROVIDER)) {
-      provider = env2.DEVSTATION_PROVIDER;
+    const named = env2.DEVSTATION_PROVIDER.toLowerCase();
+    if (isProvider(named)) {
+      provider = named;
       providerSource = "DEVSTATION_PROVIDER";
     } else {
       warnings.push(`DEVSTATION_PROVIDER="${env2.DEVSTATION_PROVIDER}" is not a provider, so it was ignored.`);
@@ -18446,7 +18467,7 @@ async function embedMissing(store, provider, options = {}) {
 import { join as join7 } from "path";
 
 // src/lib/agent/repo-session.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
 import { join as join6, relative as relative2, sep as sep2 } from "path";
 var SKIP_DIRS = new Set([
   ".git",
@@ -18490,9 +18511,9 @@ function readWorkspace(root, maxFileBytes = 1024 * 1024) {
       }
       if (!item.isFile())
         continue;
-      if (statSync3(full).size > maxFileBytes)
+      if (statSync4(full).size > maxFileBytes)
         continue;
-      const buffer = readFileSync4(full);
+      const buffer = readFileSync5(full);
       if (looksBinary(buffer))
         continue;
       files[relative2(root, full).split(sep2).join("/")] = buffer.toString("utf8");
@@ -18501,6 +18522,69 @@ function readWorkspace(root, maxFileBytes = 1024 * 1024) {
   walk3(root);
   return files;
 }
+var INDEX_SKIP_DIRS = new Set([
+  ...SKIP_DIRS,
+  "target",
+  "coverage",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".gradle",
+  "out"
+]);
+var HIDDEN_KEEP = new Set([".github"]);
+function readWorkspaceBounded(root, opts = {}) {
+  const maxFiles = opts.maxFiles ?? 20000;
+  const until = Date.now() + (opts.deadlineMs ?? 1e4);
+  const maxBytes = opts.maxFileBytes ?? 1024 * 1024;
+  const files = {};
+  let seen = 0;
+  let stopped = null;
+  const walk3 = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync3(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const item of entries) {
+      if (stopped)
+        return;
+      if (item.isSymbolicLink())
+        continue;
+      const full = join6(dir, item.name);
+      if (item.isDirectory()) {
+        if (INDEX_SKIP_DIRS.has(item.name))
+          continue;
+        if (item.name.startsWith(".") && !HIDDEN_KEEP.has(item.name))
+          continue;
+        walk3(full);
+        continue;
+      }
+      if (!item.isFile())
+        continue;
+      if (seen >= maxFiles) {
+        stopped = "max-files";
+        return;
+      }
+      if ((seen & 63) === 0 && Date.now() > until) {
+        stopped = "deadline";
+        return;
+      }
+      seen++;
+      try {
+        if (statSync4(full).size > maxBytes)
+          continue;
+        const buffer = readFileSync5(full);
+        if (looksBinary(buffer))
+          continue;
+        files[relative2(root, full).split(sep2).join("/")] = buffer.toString("utf8");
+      } catch {}
+    }
+  };
+  walk3(root);
+  return { files, stopped };
+}
 var MAX_TITLE = 72;
 function proposalFor(goal, result, files) {
   const firstLine = (goal || result.summary).split(`
@@ -18869,7 +18953,7 @@ class MemoryStore {
     this.db.run("DELETE FROM chunks WHERE path = ?", [path4]);
     this.db.run("DELETE FROM files WHERE path = ?", [path4]);
   }
-  reindex(files) {
+  reindex(files, options = {}) {
     const result = { scanned: 0, reindexed: 0, removed: 0, chunks: 0 };
     this.db.run("BEGIN");
     try {
@@ -18882,9 +18966,11 @@ class MemoryStore {
         result.chunks += this.replaceFile(path4, content);
         result.reindexed++;
       }
-      for (const gone of known) {
-        this.removeFile(gone);
-        result.removed++;
+      if (!options.partial) {
+        for (const gone of known) {
+          this.removeFile(gone);
+          result.removed++;
+        }
       }
       this.db.run("COMMIT");
     } catch (error2) {
@@ -18969,8 +19055,27 @@ function openStore(root) {
   return new MemoryStore(storePath(root));
 }
 async function indexWorkspace(root, options = {}) {
+  const started = Date.now();
+  const home = options.home ?? process.env.HOME ?? "";
+  const strip2 = (p) => p.replace(/\/+$/, "");
+  if (home && strip2(root) === strip2(home)) {
+    return {
+      scanned: 0,
+      reindexed: 0,
+      removed: 0,
+      chunks: 0,
+      embedded: 0,
+      embeddingModel: null,
+      stopped: "home",
+      ms: 0
+    };
+  }
   const store = options.store ?? openStore(root);
-  const result = store.reindex(readWorkspace(root));
+  const read = readWorkspaceBounded(root, {
+    maxFiles: options.maxFiles,
+    deadlineMs: options.deadlineMs
+  });
+  const result = store.reindex(read.files, { partial: read.stopped !== null });
   let embedded = 0;
   if (options.embeddings) {
     try {
@@ -18979,11 +19084,17 @@ async function indexWorkspace(root, options = {}) {
       embedded = 0;
     }
   }
-  return { ...result, embedded, embeddingModel: options.embeddings?.model ?? null };
+  return {
+    ...result,
+    embedded,
+    embeddingModel: options.embeddings?.model ?? null,
+    stopped: read.stopped,
+    ms: Date.now() - started
+  };
 }
 
 // src/lib/agent/memory/project-memory.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname6, join as join8 } from "path";
 var DEFAULT_FILE = "PROJECT_MEMORY.md";
 var HEADER = `# Project memory
@@ -19002,7 +19113,7 @@ function readMemory(root) {
   const path4 = memoryPath(root);
   if (!existsSync5(path4))
     return [];
-  return parseMemory(readFileSync5(path4, "utf8"));
+  return parseMemory(readFileSync6(path4, "utf8"));
 }
 var ENTRY = /^- \[([^\]]+)\](?:\s*\(([^)]*)\))?\s+([\s\S]*)$/;
 function parseMemory(text) {
@@ -19026,7 +19137,7 @@ function remember(root, note, tag = null, now = new Date) {
   if (!text) {
     return { ok: false, path: path4, message: "There was nothing to remember." };
   }
-  const existing = existsSync5(path4) ? readFileSync5(path4, "utf8") : "";
+  const existing = existsSync5(path4) ? readFileSync6(path4, "utf8") : "";
   const entries = parseMemory(existing);
   const normal = (value) => value.toLowerCase().replace(/\s+/g, " ").trim();
   if (entries.some((entry) => normal(entry.note) === normal(text))) {
@@ -19062,7 +19173,7 @@ function renderMemory(entries) {
 
 // src/lib/agent/mcp.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
 import { join as join9 } from "path";
 function configPaths(root, home = process.env.HOME ?? "") {
   return [
@@ -19077,7 +19188,7 @@ function loadConfig(root, home = process.env.HOME ?? "") {
     if (!existsSync6(path4))
       continue;
     try {
-      const parsed = JSON.parse(readFileSync6(path4, "utf8"));
+      const parsed = JSON.parse(readFileSync7(path4, "utf8"));
       for (const [name, server] of Object.entries(parsed.mcpServers ?? {})) {
         if (server && typeof server.command === "string")
           merged.mcpServers[name] = server;
@@ -19337,11 +19448,11 @@ function failedResult(message) {
 
 // src/lib/agent/sandbox-exec.ts
 import { randomBytes } from "crypto";
-import { existsSync as existsSync8, statSync as statSync5, unlinkSync } from "fs";
+import { existsSync as existsSync8, statSync as statSync6, unlinkSync } from "fs";
 import { isAbsolute as isAbsolute3, join as join11, relative as relative4, resolve as resolve3, sep as sep4 } from "path";
 
 // src/lib/agent/project.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync8, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
 import { dirname as dirname7, join as join10, relative as relative3, sep as sep3 } from "path";
 var SKIP = new Set([
   "node_modules",
@@ -19368,7 +19479,7 @@ var MANIFESTS = [
 var MAX_DEPTH = 2;
 function readScripts(absolute) {
   try {
-    const parsed = JSON.parse(readFileSync7(absolute, "utf8"));
+    const parsed = JSON.parse(readFileSync8(absolute, "utf8"));
     return parsed.scripts ?? {};
   } catch {
     return {};
@@ -19401,7 +19512,7 @@ function detectManifests(root) {
         continue;
       const child = join10(dir, entry);
       try {
-        if (statSync4(child).isDirectory())
+        if (statSync5(child).isDirectory())
           scan(child, depth + 1);
       } catch {}
     }
@@ -19542,7 +19653,7 @@ var NEEDS = {
   go: ["go"]
 };
 async function probeImage(workspace, image, runtime) {
-  const ecosystems = [...new Set(detectManifests(workspace).map((m) => m.ecosystem))];
+  const ecosystems = gatingEcosystems(detectManifests(workspace));
   const wanted = [...new Set(ecosystems.flatMap((e) => NEEDS[e]))];
   if (wanted.length === 0)
     return { ok: true, missing: [], ecosystems };
@@ -19554,10 +19665,13 @@ async function probeImage(workspace, image, runtime) {
 `).map((l) => l.trim()).filter(Boolean);
   return { ok: missing.length === 0, missing, ecosystems };
 }
+function gatingEcosystems(manifests) {
+  return [...new Set(manifests.filter((m) => m.dir === "").map((m) => m.ecosystem))];
+}
 function probeProblem(probe, image) {
   if (probe.ok)
     return null;
-  return `This is a ${probe.ecosystems.join(" and ")} project, and the sandbox image ${image} has no ` + `${probe.missing.join(", ")}. Build an image that does and set DEVSTATION_SANDBOX_IMAGE, ` + "or run with --no-sandbox.";
+  return `The sandbox image ${image} has no ${probe.missing.join(", ")}, which this ${probe.ecosystems.join(" and ")} ` + "project uses, so commands that need it will fail inside the sandbox. Build an image that has it " + "and set DEVSTATION_SANDBOX_IMAGE, or run with --no-sandbox.";
 }
 function quote2(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -19672,7 +19786,7 @@ function sandboxExecutor(options) {
       return "The sandbox could not write to the workspace. Check the mount and try --no-sandbox.";
     }
     try {
-      const stat2 = statSync5(path4);
+      const stat2 = statSync6(path4);
       const [uid, gid] = user.split(":").map(Number);
       if (stat2.uid !== uid || stat2.gid !== gid) {
         return `The sandbox writes files as ${stat2.uid}:${stat2.gid} but this account is ${user}. ` + "Files it creates would not be yours to edit, and git would stop trusting the " + "repository, so it was not started. Run with --no-sandbox, or set " + "DEVSTATION_SANDBOX_USER.";
@@ -19940,8 +20054,20 @@ function fail(reason) {
 function executeFileTool(workspace, name, args) {
   switch (name) {
     case "list_files": {
-      const files = workspace.list(String(args.path ?? "."));
-      return files.length === 0 ? { ok: true, output: "The workspace is empty." } : { ok: true, output: files.join(`
+      const LIMIT = 2000;
+      const files = workspace.list(String(args.path ?? "."), LIMIT + 1);
+      if (files.length === 0)
+        return { ok: true, output: "The workspace is empty." };
+      if (files.length > LIMIT) {
+        return {
+          ok: true,
+          output: `${files.slice(0, LIMIT).join(`
+`)}
+
+` + `(Stopped at ${LIMIT} files: this directory is very large. List a subdirectory, or search for what you need.)`
+        };
+      }
+      return { ok: true, output: files.join(`
 `) };
     }
     case "read_file": {
@@ -19978,7 +20104,10 @@ function executeFileTool(workspace, name, args) {
         return fail("No search query was given.");
       const hits = [];
       let truncated = false;
-      for (const path4 of workspace.list()) {
+      const MAX_SCAN = 20000;
+      const scanned = workspace.list(".", MAX_SCAN + 1);
+      const scanLimited = scanned.length > MAX_SCAN;
+      for (const path4 of scanned.slice(0, MAX_SCAN)) {
         const file = workspace.read(path4);
         if (!file.ok)
           continue;
@@ -19997,14 +20126,18 @@ function executeFileTool(workspace, name, args) {
         if (truncated)
           break;
       }
-      if (hits.length === 0)
-        return { ok: true, output: `No match for "${args.query}".` };
+      const scanNote = scanLimited ? `
+
+(Searched the first ${MAX_SCAN} files only: this workspace is very large. Search a subdirectory.)` : "";
+      if (hits.length === 0) {
+        return { ok: true, output: `No match for "${args.query}".${scanNote}` };
+      }
       return {
         ok: true,
-        output: truncated ? `${hits.join(`
+        output: `${truncated ? `${hits.join(`
 `)}
 \u2026 more matches not shown` : hits.join(`
-`)
+`)}${scanNote}`
       };
     }
     default:
@@ -20725,10 +20858,10 @@ import {
   appendFileSync,
   existsSync as existsSync9,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync6,
   renameSync as renameSync2,
-  statSync as statSync6,
+  statSync as statSync7,
   writeFileSync as writeFileSync5
 } from "fs";
 import { join as join12 } from "path";
@@ -20791,7 +20924,7 @@ class SessionStore {
     if (!existsSync9(path4))
       return null;
     try {
-      return JSON.parse(readFileSync8(path4, "utf8"));
+      return JSON.parse(readFileSync9(path4, "utf8"));
     } catch {
       return null;
     }
@@ -20813,10 +20946,10 @@ class SessionStore {
     const path4 = this.eventPath(id);
     if (!existsSync9(path4))
       return { events: [], offset: 0 };
-    const size = statSync6(path4).size;
+    const size = statSync7(path4).size;
     if (size <= fromByte)
       return { events: [], offset: size };
-    const text = readFileSync8(path4, "utf8").slice(fromByte);
+    const text = readFileSync9(path4, "utf8").slice(fromByte);
     const events = [];
     let consumed = 0;
     for (const line of text.split(`
@@ -20911,7 +21044,8 @@ function renderSessions(records) {
 }
 
 // src/lib/agent/cli/commands.ts
-async function buildExecutor(root, sandbox) {
+async function buildExecutor(root, sandbox, warn = (message) => process.stderr.write(`warning: ${message}
+`)) {
   if (!sandbox)
     return { executor: hostExecutor() };
   const readiness = await sandboxReadiness();
@@ -20921,7 +21055,7 @@ async function buildExecutor(root, sandbox) {
   const probe = await probeImage(root, readiness.imageName, readiness.runtimeName);
   const mismatch = probeProblem(probe, readiness.imageName);
   if (mismatch)
-    return { problem: mismatch };
+    warn(mismatch);
   return { executor: sandboxExecutor({ workspace: root }) };
 }
 function isYes(answer) {
@@ -20959,9 +21093,21 @@ async function runCommand(context, goal, options = {}) {
     executor = built.executor;
   }
   const embeddings = embeddingsFromEnv();
+  const firstIndex = !existsSync10(storePath(context.root));
+  if (firstIndex && !options.quiet)
+    terminal.out("Indexing the workspace so the agent can search it\u2026");
   const memory = openStore(context.root);
   try {
-    await indexWorkspace(context.root, { store: memory, embeddings });
+    const indexed = await indexWorkspace(context.root, { store: memory, embeddings });
+    if (!options.quiet) {
+      if (indexed.stopped === "home") {
+        terminal.err("Not indexing your home directory. The agent can still read and list files; cd into a project for a real index.");
+      } else if (indexed.stopped) {
+        terminal.err(`Indexed ${indexed.scanned} files and stopped at the ${indexed.stopped === "deadline" ? "time" : "file"} limit: this workspace is very large. cd into the project you mean.`);
+      } else if (firstIndex || indexed.ms > 1500) {
+        terminal.out(`Indexed ${indexed.scanned} files in ${(indexed.ms / 1000).toFixed(1)}s.`);
+      }
+    }
   } catch {}
   const mcp = await McpHub.start(loadConfig(context.root));
   for (const status of mcp.status) {
@@ -21254,6 +21400,14 @@ ${r.problem}`);
 function home() {
   return process.env.HOME ?? "";
 }
+function homeDirectoryWarning(root, homeDir = process.env.HOME ?? "") {
+  if (!homeDir)
+    return null;
+  const strip2 = (p) => p.replace(/\/+$/, "");
+  if (strip2(root) !== strip2(homeDir))
+    return null;
+  return "You are in your home directory, so the agent treats everything under it as one project, " + "every repository inside it included. cd into the project you mean first.";
+}
 function configEditCommand(context, rest, opts = {}) {
   const [action, key, ...valueWords] = rest.trim().split(/\s+/);
   const value = valueWords.join(" ").trim();
@@ -21289,7 +21443,7 @@ function configEditCommand(context, rest, opts = {}) {
       context.terminal.err(`Give it a value: devstation config set ${name} <value>`);
       return 2;
     }
-    if (name === "provider" && !PROVIDER_IDS.includes(value)) {
+    if (name === "provider" && !PROVIDER_IDS.includes(value.toLowerCase())) {
       context.terminal.err(`Unknown provider "${value}". Providers: ${PROVIDER_IDS.join(", ")}.`);
       return 2;
     }
@@ -21297,7 +21451,7 @@ function configEditCommand(context, rest, opts = {}) {
       context.terminal.err("baseUrl must start with http:// or https://.");
       return 2;
     }
-    current[name] = name === "baseUrl" ? value.replace(/\/+$/, "") : value;
+    current[name] = name === "baseUrl" ? value.replace(/\/+$/, "") : name === "provider" ? value.toLowerCase() : value;
     writeSettingsFile(path4, current);
     context.terminal.out(`Set ${name} = ${current[name]} in ${path4}.`);
     return 0;
@@ -21308,13 +21462,13 @@ function configEditCommand(context, rest, opts = {}) {
 async function loginCommand(context, rest) {
   const t = context.terminal;
   const secret = t.askSecret ? (q) => t.askSecret(q) : (q) => t.ask(q);
-  let provider = rest.trim().split(/\s+/)[0];
+  let provider = (rest.trim().split(/\s+/)[0] ?? "").toLowerCase();
   if (!provider) {
     t.out("Which provider?");
     t.out("  anthropic   Claude, directly (prompt caching, native tool use)");
     t.out("  openrouter  one key for Claude, GPT, Gemini, DeepSeek and more");
     t.out("  openai      OpenAI, or any compatible server: Ollama, LM Studio, Groq, Together");
-    provider = (await t.ask("provider [anthropic]: ")).trim() || "anthropic";
+    provider = (await t.ask("provider [anthropic]: ")).trim().toLowerCase() || "anthropic";
   }
   if (!PROVIDER_IDS.includes(provider)) {
     t.err(`Unknown provider "${provider}". Providers: ${PROVIDER_IDS.join(", ")}.`);
@@ -21372,7 +21526,7 @@ async function loginCommand(context, rest) {
 }
 function logoutCommand(context, rest) {
   const h = home();
-  const target = rest.trim().split(/\s+/)[0];
+  const target = (rest.trim().split(/\s+/)[0] ?? "").toLowerCase();
   if (target && !PROVIDER_IDS.includes(target)) {
     context.terminal.err(`Unknown provider "${target}". Providers: ${PROVIDER_IDS.join(", ")}.`);
     return 2;
@@ -22135,6 +22289,169 @@ function lineReader(rl, write) {
   };
 }
 
+// src/lib/agent/cli/upgrade.ts
+import { spawnSync } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync8, readFileSync as readFileSync10, renameSync as renameSync3, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname8, join as join14 } from "path";
+var PACKAGE = "@devstationlabs/cli";
+var REPO = "linoxbt/dev-shipyard";
+var DAY_MS = 24 * 60 * 60 * 1000;
+function installMethod(execPath = process.execPath, script = process.argv[1] ?? "") {
+  const slash = (p) => p.replace(/\\/g, "/");
+  const marker = `node_modules/${PACKAGE}/`;
+  if (slash(execPath).includes(marker) || slash(script).includes(marker))
+    return "npm";
+  if (/\.(ts|tsx)$/.test(script) && /(^|\/)bun(\.exe)?$/.test(slash(execPath)))
+    return "source";
+  return "binary";
+}
+function compareVersions(a, b) {
+  const parts = (v) => v.split("-")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const [x, y] = [parts(a), parts(b)];
+  for (let i = 0;i < Math.max(x.length, y.length); i++) {
+    const d = (x[i] ?? 0) - (y[i] ?? 0);
+    if (d !== 0)
+      return d > 0 ? 1 : -1;
+  }
+  return 0;
+}
+async function latestVersion(fetchImpl = fetch, timeoutMs = 4000) {
+  try {
+    const res = await fetchImpl(`https://registry.npmjs.org/${PACKAGE.replace("/", "%2f")}/latest`, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok)
+      return null;
+    const body = await res.json();
+    return typeof body.version === "string" ? body.version : null;
+  } catch {
+    return null;
+  }
+}
+function targetFor(platform = process.platform, arch = process.arch) {
+  const map = {
+    "linux-x64": "devstation-linux-x64",
+    "linux-arm64": "devstation-linux-arm64",
+    "darwin-arm64": "devstation-darwin-arm64",
+    "darwin-x64": "devstation-darwin-x64",
+    "win32-x64": "devstation-windows-x64.exe"
+  };
+  return map[`${platform}-${arch}`] ?? null;
+}
+function runInherit(command, args) {
+  const result = spawnSync(command, args, { stdio: "inherit" });
+  if (result.error)
+    return 127;
+  return result.status ?? 1;
+}
+async function upgradeCommand(context, opts = {}) {
+  const t = context.terminal;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const latest = await latestVersion(fetchImpl);
+  if (!latest) {
+    t.err("Could not reach the npm registry to check for a newer version. Nothing was changed.");
+    return 1;
+  }
+  if (compareVersions(latest, VERSION) <= 0) {
+    t.out(`devstation ${VERSION} is the latest version.`);
+    return 0;
+  }
+  t.out(`devstation ${latest} is available (you have ${VERSION}).`);
+  const method = installMethod(opts.execPath, opts.script);
+  if (opts.check) {
+    t.out(method === "source" ? "This is a source checkout: update it with git pull." : "Upgrade with: devstation upgrade");
+    return 0;
+  }
+  switch (method) {
+    case "npm": {
+      t.out(`Installed through npm, so upgrading through npm: npm install -g ${PACKAGE}@${latest}`);
+      const code = (opts.run ?? runInherit)("npm", ["install", "-g", `${PACKAGE}@${latest}`]);
+      if (code !== 0) {
+        t.err(`npm exited with ${code}. Nothing else was changed. Run it yourself: npm install -g ${PACKAGE}@latest`);
+        return code === 0 ? 1 : code;
+      }
+      t.out(`Upgraded to ${latest}. If your shell still runs the old one, run: hash -r`);
+      return 0;
+    }
+    case "source":
+      t.out("This is running from a source checkout. Update it with git pull, not upgrade.");
+      return 0;
+    case "binary":
+      return replaceBinary(t, latest, opts.execPath ?? process.execPath, fetchImpl);
+  }
+}
+async function replaceBinary(t, latest, execPath, fetchImpl) {
+  const target = targetFor();
+  if (!target) {
+    t.err(`There is no prebuilt binary for ${process.platform}-${process.arch}.`);
+    return 1;
+  }
+  if (process.platform === "win32") {
+    t.err(`A running .exe cannot replace itself on Windows. Download ${target} from https://github.com/${REPO}/releases/latest and swap it in.`);
+    return 1;
+  }
+  const base = `https://github.com/${REPO}/releases/download/v${latest}`;
+  t.out(`Downloading ${target} ${latest}\u2026`);
+  try {
+    const sums = await fetchImpl(`${base}/SHA256SUMS`, { redirect: "follow" });
+    if (!sums.ok)
+      throw new Error(`${sums.status} fetching the checksums`);
+    const expected = (await sums.text()).split(`
+`).map((line) => line.trim().split(/\s+/)).find(([, name]) => name === target)?.[0];
+    if (!expected)
+      throw new Error(`no checksum is published for ${target}`);
+    const bin = await fetchImpl(`${base}/${target}`, { redirect: "follow" });
+    if (!bin.ok)
+      throw new Error(`${bin.status} downloading ${target}`);
+    const body = Buffer.from(await bin.arrayBuffer());
+    const actual = createHash2("sha256").update(body).digest("hex");
+    if (actual !== expected) {
+      throw new Error(`the download does not match its checksum (expected ${expected}, got ${actual})`);
+    }
+    const partial = `${execPath}.partial`;
+    writeFileSync7(partial, body);
+    chmodSync2(partial, 493);
+    renameSync3(partial, execPath);
+  } catch (error2) {
+    const message2 = error2 instanceof Error ? error2.message : String(error2);
+    const permission = /EACCES|EPERM/.test(message2) ? " Run it with sudo, since the binary is in a system directory." : "";
+    t.err(`Upgrade failed and the installed version was left untouched: ${message2}.${permission}`);
+    return 1;
+  }
+  t.out(`Upgraded ${execPath} to ${latest}.`);
+  return 0;
+}
+function notifyIfOutdated(terminal, opts = {}) {
+  const env2 = opts.env ?? process.env;
+  if (env2.DEVSTATION_NO_UPDATE_CHECK === "1" || env2.CI)
+    return Promise.resolve();
+  const homeDir = opts.home ?? env2.HOME ?? "";
+  if (!homeDir)
+    return Promise.resolve();
+  const path4 = join14(homeDir, ".devstation", "update-check.json");
+  let cached = {};
+  try {
+    cached = JSON.parse(readFileSync10(path4, "utf8"));
+  } catch {}
+  if (cached.latest && compareVersions(cached.latest, VERSION) > 0) {
+    terminal.err(`devstation ${cached.latest} is available (you have ${VERSION}). Run: devstation upgrade`);
+  }
+  const now = opts.now ?? Date.now();
+  if (cached.checkedAt && now - cached.checkedAt < DAY_MS)
+    return Promise.resolve();
+  return latestVersion(opts.fetchImpl ?? fetch, 2500).then((latest) => {
+    if (!latest)
+      return;
+    try {
+      mkdirSync8(dirname8(path4), { recursive: true, mode: 448 });
+      writeFileSync7(path4, `${JSON.stringify({ checkedAt: now, latest })}
+`);
+    } catch {}
+  });
+}
+
 // src/lib/agent/cli/index.ts
 async function main(argv) {
   const parsed = parseArgs(argv);
@@ -22222,6 +22539,8 @@ Stopping. The session is saved; resume it with \`${CLI_NAME} resume\`.`);
         return await loginCommand(offline, parsed.rest);
       case "logout":
         return logoutCommand(offline, parsed.rest);
+      case "upgrade":
+        return await upgradeCommand(offline, { check: parsed.check });
       case "doctor":
         return await doctorCommand(offline);
       case "index":
@@ -22242,6 +22561,10 @@ Stopping. The session is saved; resume it with \`${CLI_NAME} resume\`.`);
       terminal.err(`Run \`${CLI_NAME} doctor\` to see what else is missing.`);
       return 2;
     }
+    const atHome = homeDirectoryWarning(root);
+    if (atHome)
+      terminal.err(`warning: ${atHome}`);
+    notifyIfOutdated(terminal);
     const ctx = context(root, terminal, parsed, provider);
     ctx.signal = controller.signal;
     if (parsed.command === "repo") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devstationlabs/cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "The DevStation coding agent, in your terminal.",
   "license": "MIT",
   "type": "module",