@lumoai/cli 1.0.0 → 1.1.0

package/README.md

@@ -14,6 +14,14 @@ Verify:
 lumo --version
 ```
 
+## Update
+
+```bash
+lumo update
+```
+
+Checks npm for a newer release and runs `npm install -g @lumoai/cli@latest` if one is available. The CLI also performs a background check once every 24 hours and prints a one-line notice on subsequent invocations when an upgrade is available.
+
 ## Authentication
 
 ```bash
@@ -60,6 +68,7 @@ lumo task update LUM-42 --status done
 | --------------- | ------------------------------------------------------------- |
 | `auth`          | `login`, `logout`                                             |
 | `whoami`        | Show current identity + workspace                             |
+| `update`        | Self-update to the latest npm release                         |
 | `task`          | `create`, `update`, `list`, `show`, `comment`, `context`      |
 | `session`       | `attach`, `status`, `detach` (binds Claude Code sessions)     |
 | `project`       | `list`                                                        |
@@ -74,13 +83,6 @@ lumo task create --help
 lumo sprint close --help
 ```
 
-## Environment Variables
-
-| Variable                  | Default                  | Purpose                                                       |
-| ------------------------- | ------------------------ | ------------------------------------------------------------- |
-| `LUMO_API_URL`            | `https://www.uselumo.ai` | Override the API endpoint (e.g. self-hosted Lumo instance).   |
-| `CLAUDE_CODE_SESSION_ID`  | _(set by Claude Code)_   | Required for `session attach` / `status` / `detach`.          |
-
 ## Claude Code Integration
 
 Inside a Claude Code session, the agent skill auto-discovers the CLI and uses it to load task context, bind sessions, and update task state. See the [Lumo Claude Code skill](https://github.com/Lumo-Workspace/lumo/tree/main/.claude/skills/lumo) for the full agent contract.

package/dist/cli/src/commands/update.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = update;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const update_check_1 = require("../lib/update-check");
+async function update() {
+    const pkg = require(path.resolve(__dirname, '../../../..', 'package.json'));
+    process.stdout.write(`Current: ${pkg.name}@${pkg.version}\n`);
+    process.stdout.write('Checking npm registry...\n');
+    const latest = await (0, update_check_1.fetchLatestVersion)(pkg.name, 5000);
+    if (!latest) {
+        process.stderr.write('Could not reach npm registry. Check your connection and try again.\n');
+        return 1;
+    }
+    if (latest === pkg.version) {
+        process.stdout.write(`Already on the latest version (${latest}).\n`);
+        return 0;
+    }
+    if (!(0, update_check_1.isNewer)(pkg.version, latest)) {
+        process.stdout.write(`Installed version (${pkg.version}) is ahead of the published latest (${latest}). Nothing to do.\n`);
+        return 0;
+    }
+    process.stdout.write(`Latest:  ${pkg.name}@${latest}\n\n`);
+    process.stdout.write(`Running: npm install -g ${pkg.name}@latest\n\n`);
+    return new Promise(resolve => {
+        const proc = (0, child_process_1.spawn)('npm', ['install', '-g', `${pkg.name}@latest`], {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        proc.on('close', code => resolve(code ?? 0));
+        proc.on('error', err => {
+            process.stderr.write(`Failed to launch npm: ${err.message}\n`);
+            process.stderr.write(`Fallback: run \`npm install -g ${pkg.name}@latest\` manually.\n`);
+            resolve(1);
+        });
+    });
+}

package/dist/cli/src/index.js

@@ -78,9 +78,29 @@ const doc_share_1 = require("./commands/doc-share");
 const doc_unshare_1 = require("./commands/doc-unshare");
 const doc_share_list_1 = require("./commands/doc-share-list");
 const doc_move_1 = require("./commands/doc-move");
+const update_1 = require("./commands/update");
+const update_check_1 = require("./lib/update-check");
 // Resolve package.json relative to __dirname so this works regardless of how
 // deep the compiled output ends up (flat dist/ or nested dist/cli/src/).
 const pkg = require(path.resolve(__dirname, '../../..', 'package.json'));
+// Detached background-refresh worker: re-entry point for the spawn() in
+// maybeRefreshInBackground(). Fetches latest, writes cache, exits — skipping
+// commander.parseAsync() below.
+const isUpdateCheckWorker = process.argv[2] === '__update-check' && !!process.argv[3];
+if (isUpdateCheckWorker) {
+    (0, update_check_1.runBackgroundRefresh)(process.argv[3])
+        .catch(() => { })
+        .finally(() => process.exit(0));
+}
+else {
+    (0, update_check_1.printUpdateNoticeIfAny)(pkg.name, pkg.version);
+    (0, update_check_1.maybeRefreshInBackground)(pkg.name);
+}
+// One-shot cleanup of pre-LUM-46 local state. The session→task binding
+// is now server-authoritative; the legacy global pointer and the
+// per-session sentinel directory are both obsolete. Failures are
+// swallowed so a permission glitch doesn't prevent CLI invocation.
+;
 (() => {
     const dir = process.env.LUMO_CONFIG_DIR || path.join(os.homedir(), '.lumo');
     try {
@@ -124,6 +144,10 @@ program
     .command('whoami')
     .description('Show the currently logged-in identity')
     .action(wrap(whoami_1.whoami));
+program
+    .command('update')
+    .description(`Check npm for a newer ${pkg.name} and install it globally if available.`)
+    .action(wrap(update_1.update));
 const session = program
     .command('session')
     .description('Manage per-terminal coding-session context');
@@ -485,8 +509,10 @@ hook
     .command('instructions-loaded')
     .description('Forward an InstructionsLoaded hook event to Lumo (reads JSON from stdin)')
     .action(wrap(() => (0, hook_1.hookCommand)('instructions-loaded')));
-program.parseAsync(process.argv).catch(err => {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`Error: ${msg}`);
-    process.exit(1);
-});
+if (!isUpdateCheckWorker) {
+    program.parseAsync(process.argv).catch(err => {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    });
+}

package/dist/cli/src/lib/update-check.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNewer = isNewer;
+exports.fetchLatestVersion = fetchLatestVersion;
+exports.printUpdateNoticeIfAny = printUpdateNoticeIfAny;
+exports.maybeRefreshInBackground = maybeRefreshInBackground;
+exports.runBackgroundRefresh = runBackgroundRefresh;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const https = __importStar(require("https"));
+const child_process_1 = require("child_process");
+const CACHE_FILE = path.join(process.env.LUMO_CONFIG_DIR || path.join(os.homedir(), '.lumo'), 'update-check.json');
+const CHECK_INTERVAL_MS = 1000 * 60 * 60 * 24;
+function readCache() {
+    try {
+        const raw = fs.readFileSync(CACHE_FILE, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.lastChecked !== 'number' ||
+            typeof parsed.latest !== 'string')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(cache) {
+    try {
+        fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(cache));
+    }
+    catch {
+        /* swallow — the update check is non-essential */
+    }
+}
+// Compare two dotted version strings. Returns true iff `b` is strictly newer.
+// Handles the subset of semver we actually publish: MAJOR.MINOR.PATCH with
+// no pre-release tags. Unknown segments are treated as 0.
+function isNewer(current, candidate) {
+    const c = current.split('.').map(n => parseInt(n, 10) || 0);
+    const l = candidate.split('.').map(n => parseInt(n, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        const cv = c[i] ?? 0;
+        const lv = l[i] ?? 0;
+        if (lv > cv)
+            return true;
+        if (lv < cv)
+            return false;
+    }
+    return false;
+}
+function fetchLatestVersion(name, timeoutMs = 2000) {
+    return new Promise(resolve => {
+        const url = `https://registry.npmjs.org/${encodeURIComponent(name).replace('%40', '@')}/latest`;
+        const req = https.get(url, { headers: { Accept: 'application/json' } }, res => {
+            if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+                res.resume();
+                return resolve(null);
+            }
+            let data = '';
+            res.setEncoding('utf8');
+            res.on('data', chunk => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(typeof json.version === 'string' ? json.version : null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on('error', () => resolve(null));
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            resolve(null);
+        });
+    });
+}
+// Read cached latest version and emit a one-line notice to stderr when a
+// newer version is available. Safe to call on every CLI invocation.
+function printUpdateNoticeIfAny(name, current) {
+    const cache = readCache();
+    if (!cache)
+        return;
+    if (isNewer(current, cache.latest)) {
+        process.stderr.write(`\n  ⬆ Update available: ${name} ${current} → ${cache.latest}\n    Run: lumo update\n\n`);
+    }
+}
+// Spawn a detached child to refresh the cached latest version when the cache
+// is older than CHECK_INTERVAL_MS. The child re-enters the CLI entrypoint via
+// the `__update-check` sentinel arg and exits silently when done. Failures
+// here must never affect the foreground command.
+function maybeRefreshInBackground(name) {
+    const cache = readCache();
+    if (cache && Date.now() - cache.lastChecked < CHECK_INTERVAL_MS)
+        return;
+    try {
+        const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1] || '', '__update-check', name], { detached: true, stdio: 'ignore' });
+        child.unref();
+    }
+    catch {
+        /* swallow */
+    }
+}
+// Entrypoint for the detached child. Called from index.ts when argv[2] is
+// the sentinel; performs the fetch and writes the cache, then exits.
+async function runBackgroundRefresh(name) {
+    const latest = await fetchLatestVersion(name, 5000);
+    if (latest)
+        writeCache({ lastChecked: Date.now(), latest });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumoai/cli",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Lumo CLI — manage tasks and sessions from the terminal",
   "license": "MIT",
   "author": "cli@uselumo.ai",
@@ -24,7 +24,7 @@
     "node": ">=18"
   },
   "bin": {
-    "lumo": "./dist/cli/src/index.js"
+    "lumo": "dist/cli/src/index.js"
   },
   "files": [
     "dist"