qiksy 1.0.0 → 1.1.0

package/bin/qiksy.mjs

@@ -13,7 +13,7 @@
  * Everything runs on the user's machine, on their own Claude. Nothing is uploaded.
  */
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { platform } from 'node:process';
@@ -140,6 +140,28 @@ async function isUp(port) {
   }
 }
 
+/**
+ * Who holds this port: nobody, our own tool, or a stranger.
+ *
+ * Running the installer twice is the most likely thing a non-technical person does —
+ * and before this check the second run printed green ticks (the FIRST engine was
+ * answering) followed by a raw EADDRINUSE stack trace, which reads as "it broke".
+ * All three tools answer /api/state with JSON, so that is the fingerprint.
+ */
+async function whoHolds(port) {
+  try {
+    const r = await fetch(`http://127.0.0.1:${port}/api/state`, { signal: AbortSignal.timeout(1500) });
+    if (r.ok) {
+      const ct = r.headers.get('content-type') || '';
+      if (ct.includes('json')) return 'ours';
+    }
+    return 'stranger';
+  } catch {
+    /* nothing answered on HTTP — but something may still hold the socket */
+  }
+  return pidsOn(port).length ? 'stranger' : 'free';
+}
+
 async function cmdStatus() {
   console.log(`\n${c.blue(c.b('  ◆ Qiksy'))}${c.dim('  — status')}\n`);
   let anyUp = false;
@@ -191,9 +213,178 @@ async function cmdDoctor() {
   console.log(c.dim('  Your work is kept in the data folder above — restarting never deletes it.\n'));
 }
 
+/* ══ Autostart ════════════════════════════════════════════════════════════════
+   Without this the engine lives exactly as long as the window Claude started it in
+   — close the laptop lid, reboot, and the tools "stop working" for reasons the
+   person cannot see. `install` registers it with the OS so it comes back on its own;
+   `uninstall` takes it back out. Everything is per-user: no sudo, no system files. */
+
+const AGENT_LABEL = 'app.qiksy.engine';
+
+function autostartPaths() {
+  const home = homedir();
+  return {
+    mac: join(home, 'Library', 'LaunchAgents', `${AGENT_LABEL}.plist`),
+    linux: join(home, '.config', 'systemd', 'user', 'qiksy.service'),
+    win: join(process.env.APPDATA || home, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', 'qiksy.cmd'),
+  };
+}
+
+/** The command the OS should run. Prefer this package's own entry over `npx`, which
+ *  needs the network and a cache that gets cleaned. */
+function selfCommand() {
+  return { node: process.execPath, script: join(PKG, 'bin', 'qiksy.mjs') };
+}
+
+function autostartInstalled() {
+  const p = autostartPaths();
+  try {
+    if (platform === 'darwin') return existsSync(p.mac);
+    if (isWin) return existsSync(p.win);
+    return existsSync(p.linux);
+  } catch {
+    return false;
+  }
+}
+
+function cmdInstall({ quiet = false } = {}) {
+  const p = autostartPaths();
+  const { node, script } = selfCommand();
+  const say = (line) => { if (!quiet) console.log(line); };
+  say(`\n${c.blue(c.b('  ◆ Qiksy'))}${c.dim('  — start automatically')}\n`);
+  try {
+    if (platform === 'darwin') {
+      mkdirSync(dirname(p.mac), { recursive: true });
+      writeFileSync(
+        p.mac,
+        `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${AGENT_LABEL}</string>
+  <key>ProgramArguments</key><array><string>${node}</string><string>${script}</string></array>
+  <key>EnvironmentVariables</key><dict><key>QIKSY_NO_OPEN</key><string>1</string></dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${join(DATA_HOME, 'engine.log')}</string>
+  <key>StandardErrorPath</key><string>${join(DATA_HOME, 'engine.log')}</string>
+</dict></plist>\n`
+      );
+      spawnSync('launchctl', ['unload', p.mac], { stdio: 'ignore' });
+      spawnSync('launchctl', ['load', p.mac], { stdio: 'ignore' });
+      say(c.green('  ✓ Qiksy will start by itself when you log in.'));
+    } else if (isWin) {
+      mkdirSync(dirname(p.win), { recursive: true });
+      writeFileSync(p.win, `@echo off\r\nstart "" /min "${node}" "${script}"\r\n`);
+      say(c.green('  ✓ Qiksy will start by itself when you sign in.'));
+    } else {
+      mkdirSync(dirname(p.linux), { recursive: true });
+      writeFileSync(
+        p.linux,
+        `[Unit]\nDescription=Qiksy local engine\n\n[Service]\nExecStart=${node} ${script}\nEnvironment=QIKSY_NO_OPEN=1\nRestart=always\n\n[Install]\nWantedBy=default.target\n`
+      );
+      spawnSync('systemctl', ['--user', 'daemon-reload'], { stdio: 'ignore' });
+      spawnSync('systemctl', ['--user', 'enable', '--now', 'qiksy.service'], { stdio: 'ignore' });
+      say(c.green('  ✓ Qiksy will start by itself when you log in.'));
+    }
+    say(c.dim('    Undo any time with:  npx qiksy uninstall\n'));
+    return true;
+  } catch (e) {
+    if (!quiet) {
+      console.log(c.amber(`  ! Could not set that up: ${e.message}`));
+      console.log(c.dim('    You can still start it by hand with:  npx qiksy\n'));
+    }
+    return false;
+  }
+}
+
+function cmdUninstall() {
+  const p = autostartPaths();
+  console.log(`\n${c.blue(c.b('  ◆ Qiksy'))}${c.dim('  — stop starting automatically')}\n`);
+  try {
+    if (platform === 'darwin') {
+      spawnSync('launchctl', ['unload', p.mac], { stdio: 'ignore' });
+      if (existsSync(p.mac)) rmSync(p.mac);
+    } else if (isWin) {
+      if (existsSync(p.win)) rmSync(p.win);
+    } else {
+      spawnSync('systemctl', ['--user', 'disable', '--now', 'qiksy.service'], { stdio: 'ignore' });
+      if (existsSync(p.linux)) rmSync(p.linux);
+    }
+    console.log(c.green('  ✓ It will no longer start on its own.'));
+    console.log(c.dim('    It may still be running now — turn it off with:  npx qiksy stop\n'));
+  } catch (e) {
+    console.log(c.amber(`  ! ${e.message}\n`));
+  }
+}
+
+/* ══ Staying alive ════════════════════════════════════════════════════════════
+   The people this is built for (recruiters, agencies) will not read a log, will not
+   know what a process is, and will not reason about ports. So the engine has to look
+   after itself: a tool that dies is restarted, a tool that stops answering is
+   restarted, and both are backed off so a genuinely broken tool cannot spin forever.
+   Nothing here ever asks the person to do anything. */
+
 const children = [];
+/** id → { tool, child, restarts, downSince } */
+const supervised = new Map();
+const MAX_QUICK_RESTARTS = 5; // within RESTART_WINDOW, then we slow right down
+const RESTART_WINDOW = 60_000;
+
+function scheduleRestart(tool, why) {
+  const s = supervised.get(tool.id);
+  if (!s || s.stopping) return;
+  const now = Date.now();
+  if (!s.windowStart || now - s.windowStart > RESTART_WINDOW) {
+    s.windowStart = now;
+    s.restarts = 0;
+  }
+  s.restarts++;
+  // 1s, 2s, 4s, 8s… capped: a tool broken for a real reason must not burn the CPU.
+  const delay = Math.min(1000 * 2 ** Math.max(0, s.restarts - 1), 30_000);
+  if (s.restarts > MAX_QUICK_RESTARTS) {
+    if (!s.warned) {
+      console.log(c.amber(`  ! ${tool.name} keeps stopping. It will keep retrying quietly in the background.`));
+      console.log(c.dim(`    If you need it now:  npx qiksy doctor`));
+      s.warned = true;
+    }
+  } else if (process.env.QIKSY_DEBUG) {
+    console.log(c.dim(`  · restarting ${tool.name} (${why}) in ${Math.round(delay / 1000)}s`));
+  }
+  s.timer = setTimeout(() => {
+    if (!s.stopping) start(tool, true);
+  }, delay);
+}
 
-function start(tool) {
+/** Every 30s: is each tool still answering? A hung process holds its port but serves
+ *  nothing, which looks exactly like "the tool broke" from the browser. */
+function startWatchdog() {
+  const timer = setInterval(async () => {
+    for (const [, s] of supervised) {
+      if (s.stopping || !s.child) continue;
+      const alive = await isUp(s.tool.port);
+      if (alive) {
+        s.downSince = 0;
+        continue;
+      }
+      // Two consecutive misses before acting — one slow moment is not a death.
+      if (!s.downSince) {
+        s.downSince = Date.now();
+        continue;
+      }
+      if (Date.now() - s.downSince < 25_000) continue;
+      s.downSince = 0;
+      try {
+        s.child.kill('SIGKILL');
+      } catch {
+        /* already gone */
+      }
+      // its 'exit' handler schedules the restart
+    }
+  }, 30_000);
+  timer.unref?.();
+}
+
+function start(tool, isRestart = false) {
   const dir0 = join(PKG, 'tools', tool.id, 'vendor');
   const entry = join(dir0, 'server.mjs');
   if (!existsSync(entry)) return null;
@@ -212,15 +403,40 @@ function start(tool) {
   // three-way tail stays readable.
   const tag = c.dim(`[${tool.id}] `);
   child.stdout?.on('data', (d) => process.stdout.write(String(d).replace(/^/gm, tag)));
-  child.stderr?.on('data', (d) => process.stderr.write(String(d).replace(/^/gm, tag)));
-  child.on('exit', (code) => {
-    if (code && code !== 0) console.log(c.red(`  ✗ ${tool.name} stopped (exit ${code})`));
+  // A Node stack trace tells the person nothing and reads as "it broke". Keep the
+  // detail for QIKSY_DEBUG, and say the one useful sentence instead.
+  child.stderr?.on('data', (d) => {
+    const s = String(d);
+    if (process.env.QIKSY_DEBUG) return process.stderr.write(s.replace(/^/gm, tag));
+    if (/EADDRINUSE/.test(s)) {
+      console.log(c.amber(`  ! ${tool.name} could not start — port ${tool.port} is already in use.`));
+      console.log(c.dim('    Check with:  npx qiksy status'));
+      return;
+    }
+    if (/^\s*(at |node:|throw |\^|Error:)/m.test(s) && !/warn/i.test(s)) return; // swallow the trace
+    process.stderr.write(s.replace(/^/gm, tag));
   });
+  child.on('exit', (code, signal) => {
+    const s = supervised.get(tool.id);
+    if (!s || s.stopping) return;
+    s.child = null;
+    // Bring it back. This is the whole point: the person must never have to notice.
+    scheduleRestart(tool, signal || `exit ${code}`);
+  });
+
+  const rec = supervised.get(tool.id) || { tool, restarts: 0 };
+  rec.tool = tool;
+  rec.child = child;
+  supervised.set(tool.id, rec);
   children.push(child);
   return child;
 }
 
 function stopAll() {
+  for (const [, s] of supervised) {
+    s.stopping = true;
+    if (s.timer) clearTimeout(s.timer);
+  }
   for (const ch of children) {
     try {
       ch.kill('SIGTERM');
@@ -245,13 +461,17 @@ process.on('SIGTERM', () => {
   if (cmd === 'status') return cmdStatus();
   if (cmd === 'stop') return cmdStop();
   if (cmd === 'doctor' || cmd === 'check') return cmdDoctor();
+  if (cmd === 'install' || cmd === 'autostart') return cmdInstall();
+  if (cmd === 'uninstall') return cmdUninstall();
   if (cmd === 'help' || cmd === '--help' || cmd === '-h') {
     console.log(`\n${c.blue(c.b('  ◆ Qiksy'))}${c.dim('  — your local engine')}\n`);
     console.log('  npx qiksy            start everything (keep the window open)');
     console.log('  npx qiksy status     what is running right now');
     console.log('  npx qiksy stop       turn it off');
     console.log('  npx qiksy restart    turn it off and on again');
-    console.log('  npx qiksy doctor     check what is wrong\n');
+    console.log('  npx qiksy doctor     check what is wrong');
+    console.log('  npx qiksy install    start automatically when you log in');
+    console.log('  npx qiksy uninstall  stop starting automatically\n');
     return;
   }
   if (cmd === 'restart') {
@@ -270,8 +490,40 @@ process.on('SIGTERM', () => {
     console.log(c.dim('    The tools still open and show you how to connect it.\n'));
   }
 
-  const started = [];
+  // Look before binding: an already-running engine must be reported as good news, and
+  // a port held by someone else must be explained, not crashed on.
+  const plan = [];
   for (const tool of TOOLS) {
+    plan.push({ tool, holder: await whoHolds(tool.port) });
+  }
+
+  const already = plan.filter((p) => p.holder === 'ours');
+  const blocked = plan.filter((p) => p.holder === 'stranger');
+
+  if (already.length === TOOLS.length) {
+    console.log(c.green('  ✓ Already running — nothing to do.\n'));
+    for (const { tool } of already) console.log(c.dim(`    ${tool.name.padEnd(18)} http://localhost:${tool.port}`));
+    console.log(c.b('\n  Go back to your Qiksy tab — it is connected.'));
+    console.log(c.dim('  Turn it off with:  npx qiksy stop\n'));
+    return;
+  }
+
+  for (const { tool } of already) {
+    console.log(c.green(`  ✓ ${tool.name.padEnd(18)} already running`));
+  }
+  for (const { tool } of blocked) {
+    console.log(c.amber(`  ! ${tool.name.padEnd(18)} port ${tool.port} is used by another program`));
+    console.log(c.dim(`    ${tool.name} will stay off until that program is closed. Everything else still works.`));
+  }
+
+  const toStart = plan.filter((p) => p.holder === 'free').map((p) => p.tool);
+  if (!toStart.length) {
+    console.log(c.dim('\n  Nothing left to start.\n'));
+    return;
+  }
+
+  const started = [];
+  for (const tool of toStart) {
     const ch = start(tool);
     if (ch) started.push(tool);
     else console.log(c.dim(`  – ${tool.name} is not bundled in this build`));
@@ -294,9 +546,20 @@ process.on('SIGTERM', () => {
     if (ok) up.push(tool);
   }
 
+  startWatchdog();
+
   console.log('');
   console.log(c.b('  Everything is running. Go back to your Qiksy tab — it connects on its own.'));
-  console.log(c.dim('  Keep this window open while you work.  Ctrl+C to stop.\n'));
+
+  // Register autostart on the FIRST successful run, without being asked. The target
+  // user will not run a second command, and an engine that dies with the window is
+  // an engine that "randomly stops working" — the single worst failure for them.
+  // Opt out with QIKSY_NO_AUTOSTART=1, undo with `npx qiksy uninstall`.
+  if (up.length && !process.env.QIKSY_NO_AUTOSTART && !autostartInstalled()) {
+    const ok = cmdInstall({ quiet: true });
+    if (ok) console.log(c.dim('  From now on it starts by itself when you log in (undo: npx qiksy uninstall).'));
+  }
+  console.log(c.dim('  You can close this window — it keeps running.  Turn it off: npx qiksy stop\n'));
 
   if (up.length && !process.env.QIKSY_NO_OPEN) openBrowser('https://qiksy.app/');
 })();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qiksy",
-  "version": "1.0.0",
-  "description": "Qiksy — one local engine for every Qiksy tool (Work Finder, Travel Assistant, Client Finder). Runs on your own Claude; nothing leaves your machine.",
+  "version": "1.1.0",
+  "description": "Qiksy \u2014 one local engine for every Qiksy tool (Work Finder, Travel Assistant, Client Finder). Runs on your own Claude; nothing leaves your machine.",
   "type": "module",
   "bin": {
     "qiksy": "bin/qiksy.mjs"

package/tools/travel/vendor/lib/store.mjs

@@ -25,6 +25,11 @@ const SETTINGS_DEFAULTS = {
   model: 'sonnet', browserSearch: false, extraInstructions: '',
   plan: 'free', license: '', licenseInfo: null,
   brandName: '', brandContact: '', brandNote: '',
+  /* Renewal reminders are ON by default and can be turned OFF here — someone who
+     tried Pro for a month and went back to Free should not be nagged forever, and
+     the switch belongs next to the plan, not in the sidebar the badge appears in
+     (owner decision 2026-07-26). */
+  renewalNotice: true,
 };
 
 /** Своя группа — «я и моя семья». Есть всегда, создаётся молча: на free человек

package/tools/travel/vendor/server.mjs

@@ -93,6 +93,9 @@ function billingInfo() {
     travelerLimit: isFinite(p.travelerLimit) ? p.travelerLimit : null,
     teamLimit: isFinite(p.travelerLimit) ? p.travelerLimit : null,
     manualPlan: db.settings.plan,
+    // Days until the paid term ends (null = nothing paid / no expiry). The UI warns
+    // from a week out, because a tool that goes quiet without notice feels broken.
+    daysLeft: li && li.paidUntil ? Math.ceil((li.paidUntil - Date.now()) / 86400000) : null,
     license: {
       set: !!db.settings.license,
       key: db.settings.license ? db.settings.license.slice(0, 6) + '…' : '',
@@ -128,6 +131,18 @@ function rollback(trip, fromStatus, toStatus, activityText) {
 
 const tripTravelers = trip => trip.travelerIds.map(id => db.team.find(m => m.id === id)).filter(Boolean);
 
+/* Когда оплаченный срок кончился, план сам падает на free (lib/license.mjs) — а
+   значит НОВАЯ работа по чужим клиентам останавливается: запустить поиск или
+   оформление для группы, которая не своя, больше нельзя (решение владельца
+   26.07.2026). Уже найденное остаётся на месте: поездки, варианты, отчёты видны и
+   копируются. Данные — не заложник, платная — работа. Свои поездки идут как на free. */
+const isOwnParty = trip => {
+  const self = db.parties[0];
+  return !trip.partyId || !self || trip.partyId === self.id;
+};
+const paidPlan = () => ['pro', 'dev'].includes(effectivePlanId());
+const clientWorkAllowed = trip => paidPlan() || isOwnParty(trip);
+
 /* Jobs live in memory, trip statuses live on disk — so a server restart (an edit, a
    crash, a reboot) left trips frozen mid-flight: "searching" forever, with no job
    behind it and nothing but "Cancel trip" to press. Roll those back at boot and say
@@ -562,6 +577,7 @@ const server = createServer(async (req, res) => {
       for (const k of ['brandName', 'brandContact', 'brandNote']) {
         if (k in body) body[k] = String(body[k] || '').slice(0, 400);
       }
+      if ('renewalNotice' in body) body.renewalNotice = !!body.renewalNotice;
       // Платные планы включаются лицензией: руками только free/dev.
       if ('plan' in body && !SELF_SETTABLE_PLANS.includes(body.plan)) delete body.plan;
       delete body.license;
@@ -670,6 +686,7 @@ const server = createServer(async (req, res) => {
         if (!['draft', 'options'].includes(t.status)) {
           return json(res, 400, { error: `поиск доступен из статусов draft/options (сейчас: ${t.status})` });
         }
+        if (!clientWorkAllowed(t)) return json(res, 402, { error: 'PLAN_REQUIRED' });
         if (!tripTravelers(t).length) return json(res, 400, { error: 'выберите хотя бы одного путника из команды' });
         // повторный поиск перезаписывает прошлый подбор
         t.options = [];
@@ -690,6 +707,7 @@ const server = createServer(async (req, res) => {
         if (!['options', 'ready_to_pay'].includes(t.status)) {
           return json(res, 400, { error: `оформление доступно из статуса options (сейчас: ${t.status})` });
         }
+        if (!clientWorkAllowed(t)) return json(res, 402, { error: 'PLAN_REQUIRED' });
         if (!t.options.some(o => o.n === num)) return json(res, 400, { error: `варианта №${num} нет в подборе` });
         if (!db.team.some(m => m.id === t.travelerIds[0])) return json(res, 400, { error: 'у поездки нет путника с карточкой' });
         const prev = t.status;