qiksy 1.2.0 → 1.2.2

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, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { platform } from 'node:process';
@@ -40,6 +40,15 @@ try {
   /* unwritable home: each backend falls back to its own folder */
 }
 
+/* The supervisor's own pid. `stop` used to kill the three tools by port — and the
+   supervisor, doing exactly what it was built for, brought them back two seconds later,
+   so stopping never actually stopped (found 2026-07-26 while upgrading a live install).
+   It records its pid here and `stop` ends the supervisor first. */
+const PID_FILE = join(DATA_HOME, 'engine.pid');
+const writePid = () => { try { writeFileSync(PID_FILE, String(process.pid)); } catch { /* unwritable home */ } };
+const readPid = () => { try { return Number(readFileSync(PID_FILE, 'utf8').trim()) || 0; } catch { return 0; } };
+const clearPid = () => { try { if (existsSync(PID_FILE)) rmSync(PID_FILE); } catch { /* ignore */ } };
+
 const TOOLS = [
   {
     id: 'work-finder',
@@ -180,14 +189,20 @@ async function cmdStatus() {
 function cmdStop() {
   console.log(`\n${c.blue(c.b('  ◆ Qiksy'))}${c.dim('  — stopping')}\n`);
   let killed = 0;
+  // Who was actually up BEFORE we touch anything — killing the supervisor takes its
+  // children with it, and reporting "was not running" about something we just stopped
+  // is the kind of small lie that makes people distrust the rest of the output.
+  const wasUp = new Map(TOOLS.map((t) => [t.id, pidsOn(t.port).length > 0]));
+  // The supervisor first, or it restarts every tool we are about to stop.
+  const sup = readPid();
+  if (sup && sup !== process.pid) { if (killPid(sup)) killed++; clearPid(); }
   for (const t of TOOLS) {
-    const pids = pidsOn(t.port);
-    if (!pids.length) {
-      console.log(c.dim(`  · ${t.name.padEnd(18)} was not running`));
-      continue;
-    }
-    for (const p of pids) if (killPid(p)) killed++;
-    console.log(c.green(`  ✓ ${t.name.padEnd(18)} stopped`));
+    for (const p of pidsOn(t.port)) if (killPid(p)) killed++;
+    console.log(
+      wasUp.get(t.id)
+        ? c.green(`  ✓ ${t.name.padEnd(18)} stopped`)
+        : c.dim(`  · ${t.name.padEnd(18)} was not running`)
+    );
   }
   console.log(c.dim(`\n  ${killed ? 'Everything is off.' : 'Nothing was running.'}  Start again: npx qiksy\n`));
 }
@@ -448,10 +463,12 @@ function stopAll() {
 process.on('SIGINT', () => {
   console.log(c.dim('\n  Stopping…'));
   stopAll();
+  clearPid();
   process.exit(0);
 });
 process.on('SIGTERM', () => {
   stopAll();
+  clearPid();
   process.exit(0);
 });
 
@@ -546,6 +563,7 @@ process.on('SIGTERM', () => {
     if (ok) up.push(tool);
   }
 
+  writePid();
   startWatchdog();
 
   console.log('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qiksy",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "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": {

package/tools/work-finder/vendor/lib/jobs.mjs

@@ -20,7 +20,12 @@ const MAX_CONCURRENT = 2;
 let running = 0;
 const queue = [];
 
-export function createJob(type, label, work) {
+/** Set by the server: called when a job dies because Claude's limit is spent. */
+let onLimit = null;
+export function setLimitHandler(fn) { onLimit = fn; }
+
+/** @param {object} [opts] `retry` describes how to run this again (see resume-later). */
+export function createJob(type, label, work, opts = {}) {
   const job = {
     id: uid(),
     type,
@@ -31,6 +36,7 @@ export function createJob(type, label, work) {
     error: null,
     createdAt: Date.now(),
     finishedAt: null,
+    retry: opts.retry || null,
   };
   jobs.set(job.id, job);
   queue.push({ job, work });
@@ -70,6 +76,13 @@ function pump() {
           if (err?.claudeCode) job.claudeCode = err.claudeCode;
           if (err?.resetAt) job.resetAt = err.resetAt;
           jobLog(job, `✗ ${job.error}`);
+          /* A usage limit is the one failure worth picking up later — the owner of the
+             machine may be asleep. jobs.mjs does not know HOW to re-run anything, so it
+             hands the job's own descriptor to whoever registered a handler. */
+          if (job.claudeCode === 'limit-reached' && job.retry && onLimit) {
+            try { onLimit(job.retry, { code: job.claudeCode, resetAt: job.resetAt }); }
+            catch { /* never let bookkeeping break the job's own failure path */ }
+          }
         }
       })
       .finally(() => {

package/tools/work-finder/vendor/lib/resume-later.mjs

@@ -0,0 +1,133 @@
+/**
+ * Pick the work back up when Claude's limit lifts.
+ *
+ * Hitting a usage limit is the ONE failure where the right answer is not "tell the
+ * person to try again" — they may be asleep, and the run was already paid for in
+ * attention. So a search stopped by a limit is remembered and re-run on its own; the
+ * person comes back to finished results instead of a red line (owner ask 2026-07-26).
+ *
+ * Deliberately conservative:
+ *  · only 'limit-reached' is retried. A wrong model or an empty résumé will fail again
+ *    at any hour, and a retry loop on those is just noise.
+ *  · at most MAX_TRIES attempts, spaced out — a limit that keeps re-hitting means the
+ *    account is genuinely spent, not that we should hammer it.
+ *  · the queue lives in the db, so closing the laptop does not lose it.
+ *  · the person can cancel it, and cancelling means cancelled.
+ */
+
+const MAX_TRIES = 3;
+const MIN_WAIT_MS = 10 * 60 * 1000; // never sooner than 10 min, even if reset says now
+const FALLBACK_WAIT_MS = 60 * 60 * 1000; // no parseable reset time → try in an hour
+const TICK_MS = 60 * 1000;
+
+/** ISO / unix / "3pm (Europe/Kyiv)" → epoch ms, or null when it cannot be trusted. */
+function resetToEpoch(resetAt) {
+  if (!resetAt) return null;
+  const s = String(resetAt).trim();
+  const asDate = Date.parse(s);
+  if (!Number.isNaN(asDate)) return asDate;
+  // "3pm", "3:30 pm (Europe/Kyiv)" — a wall-clock hint with no date. Read it as the
+  // NEXT occurrence of that hour in this machine's own timezone, which is where the
+  // person is sitting.
+  const m = s.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
+  if (!m) return null;
+  let h = Number(m[1]);
+  const min = Number(m[2] || 0);
+  const ap = (m[3] || '').toLowerCase();
+  if (ap === 'pm' && h < 12) h += 12;
+  if (ap === 'am' && h === 12) h = 0;
+  const d = new Date();
+  d.setHours(h, min, 0, 0);
+  if (d.getTime() <= Date.now()) d.setDate(d.getDate() + 1);
+  return d.getTime();
+}
+
+/**
+ * @param {object} opts
+ * @param {() => object} opts.getDb        current db (we persist into db.deferred)
+ * @param {(db: object) => void} opts.save
+ * @param {(entry: object) => void} opts.run  re-runs one entry; throws if it cannot
+ * @param {(entry: object, msg: string) => void} [opts.note]
+ */
+export function createResumeQueue({ getDb, save, run, note }) {
+  let timer = null;
+
+  const list = () => {
+    const db = getDb();
+    if (!Array.isArray(db.deferred)) db.deferred = [];
+    return db.deferred;
+  };
+
+  /** Remember a run to pick up later. Returns the entry, or null if not retryable. */
+  function defer(descriptor, { code, resetAt } = {}) {
+    if (code !== 'limit-reached' || !descriptor) return null;
+    const db = getDb();
+    const q = list();
+    // One pending entry per thing — a limit hit during a 5-role sweep must not queue
+    // the same role five times.
+    const key = JSON.stringify(descriptor);
+    const existing = q.find((e) => JSON.stringify(e.descriptor) === key);
+    const tries = (existing?.tries || 0) + 1;
+    if (tries > MAX_TRIES) {
+      if (existing) q.splice(q.indexOf(existing), 1);
+      save(db);
+      return null;
+    }
+    const base = resetToEpoch(resetAt);
+    const wait = base ? Math.max(base - Date.now(), MIN_WAIT_MS) : FALLBACK_WAIT_MS * tries;
+    const entry = existing || { id: 'df_' + Math.random().toString(36).slice(2, 10), descriptor, createdAt: Date.now() };
+    entry.tries = tries;
+    entry.resumeAt = Date.now() + wait;
+    entry.reason = 'limit-reached';
+    if (!existing) q.push(entry);
+    save(db);
+    note?.(entry, `отложено до ${new Date(entry.resumeAt).toLocaleString()}`);
+    return entry;
+  }
+
+  function cancel(id) {
+    const db = getDb();
+    const q = list();
+    const i = q.findIndex((e) => e.id === id);
+    if (i < 0) return false;
+    q.splice(i, 1);
+    save(db);
+    return true;
+  }
+
+  function due(now = Date.now()) {
+    return list().filter((e) => e.resumeAt <= now);
+  }
+
+  async function tick() {
+    const ready = due();
+    if (!ready.length) return;
+    const db = getDb();
+    for (const entry of ready) {
+      // Take it out FIRST: a re-run that hits the limit again will re-add itself with a
+      // longer wait, and a crash must not leave an entry that fires every minute.
+      const q = list();
+      const i = q.findIndex((e) => e.id === entry.id);
+      if (i >= 0) q.splice(i, 1);
+      save(db);
+      try {
+        await run(entry);
+        note?.(entry, 'возобновлено');
+      } catch (e) {
+        note?.(entry, `не удалось возобновить: ${e?.message || e}`);
+      }
+    }
+  }
+
+  function start() {
+    if (timer) return;
+    timer = setInterval(() => void tick(), TICK_MS);
+    timer.unref?.();
+  }
+  function stop() {
+    if (timer) clearInterval(timer);
+    timer = null;
+  }
+
+  return { defer, cancel, list, due, tick, start, stop };
+}

package/tools/work-finder/vendor/server.mjs

@@ -16,7 +16,7 @@ import { spawn } from 'node:child_process';
 import { load, save, uid, ROOT, DATA_DIR } from './lib/store.mjs';
 import { runClaude, extractJson } from './lib/agent.mjs';
 import { searchPrompt, coverLetterPrompt, autoApplyPrompt, importResumePrompt, leadsSearchPrompt, pitchPrompt, buildFromStoryPrompt } from './lib/prompts.mjs';
-import { createJob, jobLog, listJobs, getJob, cancelJob, cancelActiveByLabel, jobEvents } from './lib/jobs.mjs';
+import { createJob, jobLog, listJobs, getJob, cancelJob, cancelActiveByLabel, jobEvents, setLimitHandler } from './lib/jobs.mjs';
 import { ensureBrowser } from './scripts/launch-browser.mjs';
 import { PLANS, SELF_SETTABLE_PLANS } from './lib/plans.mjs';
 import { verifyLicense, licensePlanId, RECHECK_MS } from './lib/license.mjs';
@@ -24,6 +24,7 @@ import { ROLE_CATALOG, SENIORITY, LOCATIONS, detectRoles } from './lib/catalog.m
 import { checkMany, checkVacancyUrl } from './lib/linkcheck.mjs';
 import { probeEngine, startLogin, submitLoginCode } from './lib/engine.mjs';
 import { normalizeLinkedin } from './lib/linkedin.mjs';
+import { createResumeQueue } from './lib/resume-later.mjs';
 
 const PORT = Number(process.env.WF_PORT) || 5544;
 const PUBLIC_DIR = resolve(ROOT, 'public');
@@ -131,6 +132,23 @@ function createSearchRun(targets) {
 // (та же логика, что в purgeHistory). Остальное — нетронутая находка, шум, уходит.
 const isTouched = (v) => v.status !== 'new' || !!v.coverLetter || !!v.applyResult || !!v.pinned;
 
+/* A search stopped by Claude's usage limit comes back on its own — see
+   lib/resume-later.mjs for why only this one failure is retried. */
+const resumeQueue = createResumeQueue({
+  getDb: () => db,
+  save: (d) => save(d),
+  note: (entry, msg) => console.log(`[resume] ${entry.descriptor?.kind || '?'} ${msg}`),
+  run: (entry) => {
+    const d = entry.descriptor || {};
+    if (d.kind !== 'search') throw new Error('unknown descriptor');
+    const position = db.positions.find((p) => p.id === d.positionId);
+    if (!position) throw new Error('роль удалена');
+    startSearch(position, null);
+  },
+});
+resumeQueue.start();
+setLimitHandler((descriptor, info) => resumeQueue.defer(descriptor, info));
+
 function startSearch(position, run = null) {
   const profile = db.profiles.find(p => p.id === position.profileId) || db.profiles[0];
   return createJob('search', `Поиск: ${position.title}`, async (job, signal) => {
@@ -253,7 +271,7 @@ function startSearch(position, run = null) {
     }
     jobLog(job, `✓ добавлено: ${added}${dead ? `, отброшено битых ссылок: ${dead}` : ''} — волн: ${wave}`);
     return { found: added, added, dead, sweeps: wave, costUsd: cost };
-  });
+  }, { retry: { kind: 'search', positionId: position.id } });
 }
 
 function startCoverLetter(vacancy) {
@@ -627,7 +645,7 @@ export const requestHandler = async (req, res) => {
 
     if (req.method === 'GET' && path === '/api/state') {
       return json(res, 200, {
-        ...db, browserAlive, jobs: listJobs(), billing: billingInfo(),
+        ...db, browserAlive, jobs: listJobs(), billing: billingInfo(), deferred: resumeQueue.list(),
         catalog: ROLE_CATALOG.map(({ id, group, title, keywords }) => ({ id, group, title, keywords })),
         seniority: SENIORITY, locations: LOCATIONS,
       });
@@ -844,6 +862,12 @@ export const requestHandler = async (req, res) => {
        localStorage. That key cannot exist any more — API_KEY_LOGIN is off and there is
        no field to enter one — so all three were dead for every user while the fourth,
        which comes through here, worked. Same route for all of them now. */
+    /* "Do not bother, I will run it myself" — a promise the product makes must be
+       cancellable, or it is just something happening to you. */
+    if (req.method === 'DELETE' && seg[1] === 'deferred' && seg[2]) {
+      const ok = resumeQueue.cancel(seg[2]);
+      return json(res, ok ? 200 : 404, ok ? { ok: true } : { error: 'no such entry' });
+    }
     if (req.method === 'POST' && path === '/api/builder/text') {
       const b = await readBody(req);
       const prompt = (b.prompt || '').trim();