@devstationlabs/cli 0.1.2 → 0.1.3

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.3";
 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
 
@@ -18154,8 +18162,9 @@ function readSettingsFile(path4, problems = []) {
     const raw = JSON.parse(readFileSync3(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)}".`);
     }
@@ -18228,8 +18237,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.`);
@@ -19542,7 +19552,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 +19564,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, `'\\''`)}'`;
@@ -20911,7 +20924,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 +20935,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) {
@@ -21254,6 +21268,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 +21311,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 +21319,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 +21330,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 +21394,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 +22157,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 readFileSync9, 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(readFileSync9(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 +22407,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 +22429,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.3",
   "description": "The DevStation coding agent, in your terminal.",
   "license": "MIT",
   "type": "module",