neoagent 2.1.14 → 2.1.15

package/README.md

@@ -21,13 +21,13 @@ neoagent install
 Manage the service:
 ```bash
 neoagent status
+neoagent channel beta
 neoagent update
 neoagent fix
 neoagent logs
 ```
 
 Use `neoagent fix` if a self-edit or broken local install leaves NeoAgent in a bad state. On git installs it backs up runtime data, saves local tracked changes, resets tracked source files, reinstalls dependencies, and restarts the service.
-
 ---
 
 [⚙️ Configuration](docs/configuration.md) · [🧰 Skills](docs/skills.md) · [🐛 Issues](https://github.com/NeoLabs-Systems/NeoAgent/issues)

package/lib/manager.js

@@ -21,6 +21,14 @@ const {
   ensureRuntimeDirs,
   migrateLegacyRuntime
 } = require('../runtime/paths');
+const {
+  parseReleaseChannel,
+  getReleaseChannelBranch,
+  getReleaseChannelDistTag,
+  getReleaseChannelLabel,
+  readConfiguredReleaseChannel,
+  writeReleaseChannelToEnvFile,
+} = require('../runtime/release_channel');
 
 const APP_NAME = 'NeoAgent';
 const SERVICE_LABEL = 'com.neoagent';
@@ -184,6 +192,59 @@ function commandExists(cmd) {
   return sharedCommandExists((command, args) => runQuiet(command, args), cmd);
 }
 
+function currentReleaseChannel() {
+  return readConfiguredReleaseChannel({ envFile: ENV_FILE });
+}
+
+function releaseChannelSummary(channel) {
+  const normalized = parseReleaseChannel(channel) || currentReleaseChannel();
+  return `${getReleaseChannelLabel(normalized)} (branch ${getReleaseChannelBranch(normalized)}, npm ${getReleaseChannelDistTag(normalized)})`;
+}
+
+function gitWorkingTreeDirty() {
+  const res = runQuiet('git', ['status', '--porcelain']);
+  return res.status === 0 && Boolean(res.stdout.trim());
+}
+
+function gitLocalBranchExists(branch) {
+  return runQuiet('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]).status === 0;
+}
+
+function gitRemoteBranchExists(branch) {
+  return runQuiet('git', ['ls-remote', '--exit-code', '--heads', 'origin', branch]).status === 0;
+}
+
+function ensureGitBranchForReleaseChannel(targetBranch) {
+  const branchRes = runQuiet('git', ['rev-parse', '--abbrev-ref', 'HEAD']);
+  const currentBranch = branchRes.status === 0 ? branchRes.stdout.trim() : '';
+  if (currentBranch === targetBranch) {
+    return currentBranch;
+  }
+
+  if (!gitRemoteBranchExists(targetBranch)) {
+    throw new Error(`Release channel branch "${targetBranch}" was not found on origin.`);
+  }
+
+  if (gitWorkingTreeDirty()) {
+    throw new Error(
+      `Cannot switch to ${targetBranch} while the git worktree has local changes. Commit or stash them first, then rerun the update.`,
+    );
+  }
+
+  if (gitLocalBranchExists(targetBranch)) {
+    runOrThrow('git', ['checkout', targetBranch]);
+  } else {
+    runOrThrow('git', ['checkout', '-b', targetBranch, '--track', `origin/${targetBranch}`]);
+  }
+
+  if (currentBranch) {
+    logOk(`Switched git branch ${currentBranch} -> ${targetBranch}`);
+  } else {
+    logOk(`Checked out git branch ${targetBranch}`);
+  }
+  return targetBranch;
+}
+
 function ensureLogDir() {
   ensureRuntimeDirs();
 }
@@ -565,6 +626,7 @@ async function cmdStatus() {
   heading(`${APP_NAME} Status`);
   const port = loadEnvPort();
   const running = await isPortOpen(port);
+  const releaseChannel = currentReleaseChannel();
 
   if (running) {
     logOk(`running on http://localhost:${port}`);
@@ -574,6 +636,7 @@ async function cmdStatus() {
 
   console.log(`  install root ${APP_DIR}`);
   console.log(`  version ${currentInstalledVersionLabel()}`);
+  console.log(`  release channel ${releaseChannelSummary(releaseChannel)}`);
 
   const processes = listNeoAgentServerProcesses();
   if (processes.length > 0) {
@@ -595,23 +658,51 @@ function cmdLogs() {
   runOrThrow('tail', ['-f', log, err], { cwd: APP_DIR });
 }
 
-function cmdUpdate() {
+function cmdChannel(args = []) {
+  heading('Release Channel');
+  const requested = args[0];
+
+  if (!requested) {
+    const channel = currentReleaseChannel();
+    console.log(`  configured ${releaseChannelSummary(channel)}`);
+    return;
+  }
+
+  const nextChannel = parseReleaseChannel(requested);
+  if (!nextChannel) {
+    throw new Error('Usage: neoagent channel [stable|beta]');
+  }
+
+  writeReleaseChannelToEnvFile(nextChannel, ENV_FILE);
+  process.env.NEOAGENT_RELEASE_CHANNEL = nextChannel;
+  logOk(`Release channel set to ${releaseChannelSummary(nextChannel)}`);
+}
+
+function cmdUpdate(args = []) {
   heading(`Update ${APP_NAME}`);
   migrateLegacyRuntime((msg) => logInfo(msg));
   ensureRuntimeDirs();
+  const requestedChannel = args[0] ? parseReleaseChannel(args[0]) : null;
+  if (args[0] && !requestedChannel) {
+    throw new Error('Usage: neoagent update [stable|beta]');
+  }
+  const releaseChannel = requestedChannel || currentReleaseChannel();
+  if (requestedChannel) {
+    writeReleaseChannelToEnvFile(releaseChannel, ENV_FILE);
+    process.env.NEOAGENT_RELEASE_CHANNEL = releaseChannel;
+    logOk(`Release channel set to ${releaseChannelSummary(releaseChannel)}`);
+  }
+  const targetBranch = getReleaseChannelBranch(releaseChannel);
+  const npmTag = getReleaseChannelDistTag(releaseChannel);
   const versionBefore = currentInstalledVersionLabel();
   let versionAfter = versionBefore;
 
   if (fs.existsSync(path.join(APP_DIR, '.git')) && commandExists('git')) {
-    const branch = runQuiet('git', ['rev-parse', '--abbrev-ref', 'HEAD']);
     const current = runQuiet('git', ['rev-parse', '--short', 'HEAD']);
 
-    runOrThrow('git', ['fetch', 'origin']);
-    if (branch.status === 0) {
-      runOrThrow('git', ['pull', '--rebase', '--autostash', 'origin', branch.stdout.trim()]);
-    } else {
-      runOrThrow('git', ['pull', '--rebase', '--autostash']);
-    }
+    runOrThrow('git', ['fetch', 'origin', targetBranch]);
+    ensureGitBranchForReleaseChannel(targetBranch);
+    runOrThrow('git', ['pull', '--rebase', '--autostash', 'origin', targetBranch]);
 
     const next = runQuiet('git', ['rev-parse', '--short', 'HEAD']);
     if (current.status === 0 && next.status === 0 && current.stdout.trim() !== next.stdout.trim()) {
@@ -623,16 +714,16 @@ function cmdUpdate() {
       buildBundledWebClientIfPossible();
     }
   } else {
-    logWarn('No git repo detected; attempting npm global update.');
+    logWarn(`No git repo detected; attempting npm global update from ${npmTag}.`);
     if (commandExists('npm')) {
       try {
         backupRuntimeData();
-        runOrThrow('npm', ['install', '-g', 'neoagent@latest', '--force'], {
+        runOrThrow('npm', ['install', '-g', `neoagent@${npmTag}`, '--force'], {
           env: withInstallEnv()
         });
         logOk('npm global update completed (forced reinstall)');
       } catch {
-        logWarn('npm global update failed. Run: npm install -g neoagent@latest --force');
+        logWarn(`npm global update failed. Run: npm install -g neoagent@${npmTag} --force`);
       }
     } else {
       logWarn('npm not found. Cannot perform global update.');
@@ -702,7 +793,9 @@ async function cmdEnv(args = []) {
 function printHelp() {
   console.log(`${APP_NAME} manager`);
   console.log('Usage: neoagent <command>');
-  console.log('Commands: install | setup | env | update | restart | start | stop | status | logs | uninstall');
+  console.log('Commands: install | setup | env | channel | update | restart | start | stop | status | logs | uninstall');
+  console.log('Channel usage: neoagent channel | neoagent channel stable | neoagent channel beta');
+  console.log('Update usage: neoagent update | neoagent update stable | neoagent update beta');
   console.log('Env usage: neoagent env list | neoagent env get PORT | neoagent env set PORT 3333 | neoagent env unset PORT');
 }
 
@@ -721,8 +814,11 @@ async function runCLI(argv) {
     case 'env':
       await cmdEnv(argv.slice(1));
       break;
+    case 'channel':
+      cmdChannel(argv.slice(1));
+      break;
     case 'update':
-      cmdUpdate();
+      cmdUpdate(argv.slice(1));
       break;
     case 'restart':
       cmdRestart();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.1.14",
+  "version": "2.1.15",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/runtime/release_channel.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { ENV_FILE } = require('./paths');
+
+const DEFAULT_RELEASE_CHANNEL = 'stable';
+const RELEASE_CHANNEL_ENV_KEY = 'NEOAGENT_RELEASE_CHANNEL';
+const RELEASE_CHANNEL_BRANCHES = Object.freeze({
+  stable: 'main',
+  beta: 'beta',
+});
+const RELEASE_CHANNEL_DIST_TAGS = Object.freeze({
+  stable: 'latest',
+  beta: 'beta',
+});
+
+function parseEnv(raw) {
+  const map = new Map();
+  for (const line of String(raw || '').split('\n')) {
+    if (!line || line.startsWith('#') || !line.includes('=')) continue;
+    const idx = line.indexOf('=');
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1);
+    if (key) map.set(key, value);
+  }
+  return map;
+}
+
+function parseReleaseChannel(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  switch (normalized) {
+    case 'stable':
+    case 'normal':
+    case 'default':
+    case 'latest':
+    case 'main':
+      return 'stable';
+    case 'beta':
+    case 'preview':
+    case 'prerelease':
+    case 'pre-release':
+      return 'beta';
+    default:
+      return null;
+  }
+}
+
+function normalizeReleaseChannel(value) {
+  return parseReleaseChannel(value) || DEFAULT_RELEASE_CHANNEL;
+}
+
+function getReleaseChannelBranch(channel) {
+  return RELEASE_CHANNEL_BRANCHES[normalizeReleaseChannel(channel)];
+}
+
+function getReleaseChannelDistTag(channel) {
+  return RELEASE_CHANNEL_DIST_TAGS[normalizeReleaseChannel(channel)];
+}
+
+function getReleaseChannelLabel(channel) {
+  return normalizeReleaseChannel(channel) === 'beta' ? 'Beta' : 'Stable';
+}
+
+function readReleaseChannelFromRaw(raw) {
+  const env = parseEnv(raw);
+  return normalizeReleaseChannel(env.get(RELEASE_CHANNEL_ENV_KEY));
+}
+
+function readReleaseChannelFromEnvFile(envFile = ENV_FILE) {
+  try {
+    return readReleaseChannelFromRaw(fs.readFileSync(envFile, 'utf8'));
+  } catch {
+    return DEFAULT_RELEASE_CHANNEL;
+  }
+}
+
+function readConfiguredReleaseChannel({ env = process.env, envFile = ENV_FILE } = {}) {
+  return normalizeReleaseChannel(env[RELEASE_CHANNEL_ENV_KEY] || readReleaseChannelFromEnvFile(envFile));
+}
+
+function writeReleaseChannelToEnvFile(channel, envFile = ENV_FILE) {
+  const normalized = parseReleaseChannel(channel);
+  if (!normalized) {
+    throw new Error('Release channel must be "stable" or "beta".');
+  }
+
+  const raw = fs.existsSync(envFile) ? fs.readFileSync(envFile, 'utf8') : '';
+  const lines = raw ? raw.split('\n') : [];
+  let replaced = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith(`${RELEASE_CHANNEL_ENV_KEY}=`)) {
+      lines[i] = `${RELEASE_CHANNEL_ENV_KEY}=${normalized}`;
+      replaced = true;
+      break;
+    }
+  }
+
+  if (!replaced) {
+    lines.push(`${RELEASE_CHANNEL_ENV_KEY}=${normalized}`);
+  }
+
+  const output =
+    lines.filter((_, idx, arr) => idx !== arr.length - 1 || arr[idx] !== '').join('\n') + '\n';
+  fs.mkdirSync(path.dirname(envFile), { recursive: true });
+  fs.writeFileSync(envFile, output, { mode: 0o600 });
+  return normalized;
+}
+
+module.exports = {
+  DEFAULT_RELEASE_CHANNEL,
+  RELEASE_CHANNEL_ENV_KEY,
+  parseReleaseChannel,
+  normalizeReleaseChannel,
+  getReleaseChannelBranch,
+  getReleaseChannelDistTag,
+  getReleaseChannelLabel,
+  readReleaseChannelFromRaw,
+  readReleaseChannelFromEnvFile,
+  readConfiguredReleaseChannel,
+  writeReleaseChannelToEnvFile,
+};

package/server/index.js

@@ -53,6 +53,7 @@ registerStaticRoutes(app);
 registerErrorHandler(app);
 
 let shuttingDown = false;
+let shutdownExitCode = 0;
 
 httpServer.on('connection', (socket) => {
   activeSockets.add(socket);
@@ -146,7 +147,8 @@ function closeHttpServer(server, sockets, timeoutMs = 5000) {
   });
 }
 
-async function shutdown() {
+async function shutdown(exitCode = 0) {
+  shutdownExitCode = Math.max(shutdownExitCode, exitCode);
   if (shuttingDown) return;
   shuttingDown = true;
 
@@ -159,12 +161,15 @@ async function shutdown() {
   ]);
 
   db.close();
-  process.exit(0);
+  process.exit(shutdownExitCode);
 }
 
-httpServer.listen(PORT, async () => {
+httpServer.listen(PORT, () => {
   console.log(`NeoAgent running on http://localhost:${PORT}`);
-  await startServices(app, io);
+  startServices(app, io).catch(async (err) => {
+    console.error('[Startup] Service initialization failed:', err);
+    await shutdown(1);
+  });
 });
 
 process.on('SIGINT', shutdown);

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"052f31d115eceda8cbff1b3481fcde4330c4ae
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "1633758143" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "1964138140" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });