kenaz 0.3.22 → 0.3.23

package/core/plugins/kenaz/scripts/kenaz.test.js

@@ -58,11 +58,14 @@ test('kenaz.yaml switch is honoured; env wins', () => {
 });
 
 test('backend down: no output, no stderr, exit 0', () => {
-  for (const n of ['flow-post', 'session-start']) {
-    const r = hook(n, proj(), { KENAZ_BACKEND_PORT: '1' });
-    assert.strictEqual(r.status, 0);
-    assert.strictEqual(r.stdout + r.stderr, '');
-  }
+  const home = proj(); // temp HOME: session-start would otherwise start the real installed server (TASK_2468)
+  const env = { KENAZ_BACKEND_PORT: '1', HOME: home, USERPROFILE: home };
+  const r = hook('flow-post', proj(), env);
+  assert.strictEqual(r.status, 0);
+  assert.strictEqual(r.stdout + r.stderr, '');
+  const s = hook('session-start', proj(), env); // only session-start speaks: one line naming the fix
+  assert.strictEqual(s.stderr, '');
+  assert.match(s.stdout, /npx kenaz install/);
 });
 
 test('ygg status fixture: masked key, room, peers, mail (TASK_2366)', () => {
@@ -202,3 +205,67 @@ test('ygg create explains 429, 503, missing relay_url and unreachable relay (TAS
     await assert.rejects(createTeam(dir, '', 'project'), /cannot reach the relay at http:\/\/127\.0\.0\.1:1/);
   });
 });
+
+// TASK_2468: SessionStart starts the installed server when the port is closed (temp HOME, free port, fake server script).
+async function freePort() {
+  const srv = require('net').createServer();
+  await new Promise((r) => srv.listen(0, '127.0.0.1', r));
+  const p = srv.address().port;
+  await new Promise((r) => srv.close(r));
+  return p;
+}
+function fakeHome(withBin) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'kz-home-'));
+  fs.mkdirSync(path.join(home, '.kenaz'));
+  const bin = path.join(home, 'fake-server.js');
+  fs.writeFileSync(bin, "const http=require('http');require('fs').writeFileSync(process.env.PIDFILE,String(process.pid));" +
+    "http.createServer((q,r)=>{r.end('{}')}).listen(Number(process.env.KENAZ_BACKEND_PORT),'127.0.0.1');setTimeout(()=>process.exit(0),15000);");
+  if (withBin) fs.writeFileSync(path.join(home, '.kenaz', 'install.json'), JSON.stringify({ serverBin: bin }));
+  return { home, pidfile: path.join(home, 'pid') };
+}
+const isUp = (port) => new Promise((r) => { const s = require('net').connect({ host: '127.0.0.1', port }); s.on('connect', () => { s.destroy(); r(true); }); s.on('error', () => r(false)); });
+const killPid = (f) => { try { process.kill(Number(fs.readFileSync(f, 'utf8'))); } catch (_) { /* never started */ } };
+const hookAsync = (env) => new Promise((resolve) => {
+  const c = require('child_process').spawn(process.execPath, [HOOK, 'session-start'], { env: Object.assign({}, process.env, { CLAUDE_PROJECT_DIR: proj(), KENAZ_MODE: '', KENAZ_SOURCE_DIR: CORE }, env) });
+  let out = ''; c.stdout.on('data', (d) => { out += d; }); c.on('close', () => resolve(out)); c.stdin.end('{}');
+});
+
+test('TASK_2468: session-start with the port closed starts the installed server and says so', async () => {
+  const port = await freePort(); const f = fakeHome(true);
+  const env = { HOME: f.home, USERPROFILE: f.home, KENAZ_BACKEND_PORT: String(port), PIDFILE: f.pidfile };
+  try {
+    const out = await hookAsync(env);
+    assert.ok(await isUp(port), 'server came up');
+    assert.match(out, /started it/); assert.match(out, /\/mcp/);
+  } finally { killPid(f.pidfile); }
+});
+
+test('TASK_2468: no install.json -> one line naming `npx kenaz install` and /mcp; nothing spawned', async () => {
+  const port = await freePort(); const f = fakeHome(false);
+  const env = { HOME: f.home, USERPROFILE: f.home, KENAZ_BACKEND_PORT: String(port), PIDFILE: f.pidfile };
+  const out = await hookAsync(env);
+  assert.match(out, /npx kenaz install/); assert.match(out, /\/mcp/);
+  assert.strictEqual(out.trim().split('\n').length, 1);
+  assert.ok(!(await isUp(port)));
+});
+
+test('TASK_2468: KENAZ_MODE=off and sdk entrypoint -> no output, nothing spawned', async () => {
+  for (const extra of [{ KENAZ_MODE: 'off' }, { CLAUDE_CODE_ENTRYPOINT: 'sdk-ts' }]) {
+    const port = await freePort(); const f = fakeHome(true);
+    const env = Object.assign({ HOME: f.home, USERPROFILE: f.home, KENAZ_BACKEND_PORT: String(port), PIDFILE: f.pidfile }, extra);
+    try {
+      assert.strictEqual(await hookAsync(env), '');
+      assert.ok(!(await isUp(port)) && !fs.existsSync(f.pidfile));
+    } finally { killPid(f.pidfile); }
+  }
+});
+
+test('TASK_2468: port already answering -> nothing spawned, no extra line', async () => {
+  const port = await freePort(); const f = fakeHome(true);
+  const srv = require('http').createServer((q, r) => r.end('{}'));
+  await new Promise((r) => srv.listen(port, '127.0.0.1', r));
+  try {
+    const out = await hookAsync({ HOME: f.home, USERPROFILE: f.home, KENAZ_BACKEND_PORT: String(port), PIDFILE: f.pidfile });
+    assert.strictEqual(out, ''); assert.ok(!fs.existsSync(f.pidfile));
+  } finally { srv.close(); }
+});

package/lib/cli.js

@@ -72,8 +72,8 @@ function platformServer() {
 
 function onPath(cmd) {
   const r = process.platform === 'win32' // one string with shell (.cmd shims); args + shell:true is deprecated (DEP0190)
-    ? spawnSync(cmd + ' --version', { encoding: 'utf8', shell: true, timeout: 15000 })
-    : spawnSync(cmd, ['--version'], { encoding: 'utf8', timeout: 15000 });
+    ? spawnSync(cmd + ' --version', { windowsHide: true, encoding: 'utf8', shell: true, timeout: 15000 })
+    : spawnSync(cmd, ['--version'], { windowsHide: true, encoding: 'utf8', timeout: 15000 });
   return r.status === 0;
 }
 
@@ -244,7 +244,7 @@ async function doctor(p, flags, out, deps = {}) {
 
   try { // TASK_2413: which mechanism restarts the server after a reboot (read-only; `deps.sh` / `deps.platform` for tests)
     const sm = installer().detectServiceMode(p.home, p.core, deps.sh, deps.platform);
-    add('service mode', sm.mode === 'manual' ? 'skip' : 'ok', sm.mode + ' (' + sm.detail + ')');
+    add('service mode', sm.mode === 'manual' ? 'skip' : sm.warn ? 'warn' : 'ok', sm.mode + ' (' + sm.detail + ')');
   } catch (e) { add('service mode', 'skip', 'unknown: ' + e.message); }
   const d = dash.detect(p.home, deps.dashboard);
   if (!d.installed) add('dashboard', 'skip', 'no Kenaz Dashboard on this machine');
@@ -262,7 +262,11 @@ async function doctor(p, flags, out, deps = {}) {
   else {
     const d = { disabled: `off: ${upd.reason}`, error: `last check failed: ${upd.last_error}`, staged: `${upd.staged_version} staged, applies when idle`,
       applied: `${upd.applied_version} swapped in (previous ${upd.previous_version}), restart pending`, 'rolled-back': 'rolled back to the previous version' }[upd.state] || `${upd.state}, latest ${upd.latest_version || 'unknown'}`;
-    add('self-update', upd.state === 'disabled' ? 'skip' : 'ok', `${d} [running ${upd.current_version}]`);
+    // A staged version not newer than the running one froze older servers' updater (checks stop while one is staged).
+    const num = (v) => String(v || '').split('.').map(Number);
+    const stale = upd.staged_version && num(upd.staged_version).reduce((c, x, i) => c || x - (num(upd.current_version)[i] || 0), 0) <= 0;
+    if (stale) add('self-update', 'warn', `${upd.staged_version} staged but running ${upd.current_version}: updater stuck; delete ${path.join(p.dir, 'update', 'status.json')} and restart kenaz-server`);
+    else add('self-update', upd.state === 'disabled' ? 'skip' : upd.state === 'error' ? 'warn' : 'ok', `${d} [running ${upd.current_version}]`);
   }
 
   const inst = installer();
@@ -313,7 +317,7 @@ function passthrough(argv, deps) {
   const script = argv[0] === 'ygg' ? 'ygg.js' : 'kenaz-mode.js';
   const args = argv[0] === 'ygg' ? argv.slice(1) : argv;
   const spawn = deps.spawnSync || require('child_process').spawnSync;
-  const r = spawn(process.execPath, [path.join(core, 'plugins', 'kenaz', 'scripts', script), ...args], { stdio: 'inherit', cwd: process.cwd() });
+  const r = spawn(process.execPath, [path.join(core, 'plugins', 'kenaz', 'scripts', script), ...args], { windowsHide: true, stdio: 'inherit', cwd: process.cwd() });
   return r.status === null ? 1 : r.status;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kenaz",
-  "version": "0.3.22",
+  "version": "0.3.23",
   "description": "Install Kenaz (plugin, hooks, kenaz-server) for Claude Code and Codex: npx kenaz install",
   "bin": {
     "kenaz": "bin/kenaz.js"
@@ -20,11 +20,11 @@
     "test": "node --test lib/cli.test.js"
   },
   "optionalDependencies": {
-    "@kenazai/server-darwin-arm64": "0.3.22",
-    "@kenazai/server-darwin-x64": "0.3.22",
-    "@kenazai/server-linux-arm64": "0.3.22",
-    "@kenazai/server-linux-x64": "0.3.22",
-    "@kenazai/server-win32-x64": "0.3.22"
+    "@kenazai/server-darwin-arm64": "0.3.23",
+    "@kenazai/server-darwin-x64": "0.3.23",
+    "@kenazai/server-linux-arm64": "0.3.23",
+    "@kenazai/server-linux-x64": "0.3.23",
+    "@kenazai/server-win32-x64": "0.3.23"
   },
   "license": "UNLICENSED",
   "repository": {

package/vendor/install-kenaz-cli.js

@@ -22,6 +22,8 @@ const MIN_CLI = [2, 1, 287];
 const SEP = process.platform === 'win32' ? ';' : ':';
 const TASK_NAME = 'KenazServer';
 const LABEL = 'ai.kenaz.server';
+const BATTERY_PS = '$s = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit ([TimeSpan]::Zero); Set-ScheduledTask -TaskName ' + TASK_NAME + ' -Settings $s';
+const linuxUser = () => { try { return os.userInfo().username; } catch (_) { return process.env.USER || ''; } };
 
 const norm = (e) => {
   const s = String(e).trim().replace(/\\/g, '/').replace(/\/+$/, '');
@@ -136,8 +138,8 @@ function retireDashboardHooks(file, dry) {
 
 function claudeVersion() {
   const r = process.platform === 'win32' // one string with shell (.cmd shim): args + shell:true is deprecated (DEP0190)
-    ? spawnSync('claude --version', { encoding: 'utf8', shell: true, timeout: 15000 })
-    : spawnSync('claude', ['--version'], { encoding: 'utf8', timeout: 15000 });
+    ? spawnSync('claude --version', { windowsHide: true, encoding: 'utf8', shell: true, timeout: 15000 })
+    : spawnSync('claude', ['--version'], { windowsHide: true, encoding: 'utf8', timeout: 15000 });
   return r.status === 0 ? parseVersion(r.stdout) : null;
 }
 
@@ -208,7 +210,7 @@ function servicePlan(home, bin, core, platform = process.platform, caps = { syst
   const p = path.join(home, '.config', 'systemd', 'user', 'kenaz-server.service');
   return { kind: 'systemd', files: [[p, systemdUnit(bin, core)]], unit: p };
 }
-const sh = (cmd, args, opts) => spawnSync(cmd, args, { encoding: 'utf8', ...(opts || {}) });
+const sh = (cmd, args, opts) => spawnSync(cmd, args, { windowsHide: true, encoding: 'utf8', ...(opts || {}) });
 
 // crontab -l: null = no crontab binary; '' = binary present, no crontab yet. All through the injected `run`.
 function readCron(run) {
@@ -303,8 +305,13 @@ function serviceInstall(plan, dry, log, run = sh, uid) {
     log('schtasks /Create /TN ' + TASK_NAME + ' /SC ONLOGON /TR ' + tr + ' /F  (fallback: ' + plan.fallbackFile + ')');
     if (dry) return;
     const r = sh('schtasks', ['/Create', '/TN', TASK_NAME, '/SC', 'ONLOGON', '/TR', tr, '/F']);
-    if (r.status === 0) sh('schtasks', ['/Run', '/TN', TASK_NAME]);
-    else { // ONLOGON tasks can need elevation: a Startup-folder launcher is the per-user equivalent
+    if (r.status === 0) {
+      // Task Scheduler defaults refuse to start on battery and stop the task when going on battery:
+      // a laptop unplugged at logon never got the server (TASK_2468). Re-running install fixes an old task.
+      const b = sh('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', BATTERY_PS]);
+      if (b.status !== 0) log('WARNING: could not set the task to run on battery (exit ' + b.status + '); on a laptop the server may not start unplugged. Run in PowerShell: ' + BATTERY_PS);
+      sh('schtasks', ['/Run', '/TN', TASK_NAME]);
+    } else { // ONLOGON tasks can need elevation: a Startup-folder launcher is the per-user equivalent
       fs.mkdirSync(path.dirname(plan.fallbackFile), { recursive: true });
       fs.copyFileSync(plan.files[0][0], plan.fallbackFile);
       sh('wscript.exe', [plan.files[0][0]]);
@@ -326,6 +333,10 @@ function serviceInstall(plan, dry, log, run = sh, uid) {
   } else {
     log('systemctl --user enable --now kenaz-server');
     if (!dry) { sh('systemctl', ['--user', 'daemon-reload']); sh('systemctl', ['--user', 'enable', '--now', 'kenaz-server']); }
+    // Without linger the user service starts only at login (headless boxes: never). Best effort.
+    const u = linuxUser();
+    log('loginctl enable-linger ' + u);
+    if (!dry && sh('loginctl', ['enable-linger', u]).status !== 0) log('WARNING: could not enable linger; the server starts at boot only after you log in. Run: loginctl enable-linger ' + u + ' (may need sudo)');
     serviceRestart(plan, dry, log, sh, uid);
   }
 }
@@ -365,7 +376,11 @@ function detectServiceMode(home, core, run = sh, platform = process.platform) {
     return fs.existsSync(p) ? { mode: 'launchd', detail: p } : { mode: 'manual', detail: 'no launchd agent; run `kenaz install`' };
   }
   const unit = servicePlan(home, '', core, 'linux').unit;
-  if (fs.existsSync(unit) && probeLinux(run).systemd) return { mode: 'systemd', detail: unit };
+  if (fs.existsSync(unit) && probeLinux(run).systemd) {
+    const u = linuxUser();
+    const off = /Linger=no/.test(run('loginctl', ['show-user', u, '-p', 'Linger']).stdout || '');
+    return off ? { mode: 'systemd', detail: unit + '; linger is off, the server starts only after login: run loginctl enable-linger ' + u, warn: true } : { mode: 'systemd', detail: unit };
+  }
   const c = readCron(run);
   if (c && c.includes(CRON_MARK)) return { mode: 'cron', detail: '@reboot crontab entry (no systemd user session)' };
   return { mode: 'manual', detail: 'no systemd unit or cron entry; run `kenaz install`' };