jaitus 0.3.4 → 0.3.6

package/src/background.js

@@ -5,7 +5,7 @@
 // with background_read; /tasks lists jobs with attach/stop. `! cmd &` and
 // Ctrl+B start one from the prompt; background_run does it from the model.
 
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -36,6 +36,7 @@ export function startBackground(command, cwd) {
   child.on('close', (code) => {
     job.exit = code ?? 'signal';
     try { fs.appendFileSync(log, `\n[exit ${job.exit}]\n`); } catch { /* log gone */ }
+    try { fs.closeSync(out); } catch { /* already closed */ }
   });
   try { child.unref(); } catch { /* stay attached */ }
   job.child = child;
@@ -61,9 +62,19 @@ function findJob(id) {
 export function readBackground(id, tail = 40) {
   const job = findJob(id);
   if (!job) return null;
+  // Only the end of the log: a dev server's log grows for hours, and reading all of it on
+  // every poll put the whole file in memory each time.
   let lines = [];
   try {
-    lines = fs.readFileSync(job.log, 'utf8').split('\n');
+    const size = fs.statSync(job.log).size;
+    const from = Math.max(0, size - 64 * 1024);
+    const fd = fs.openSync(job.log, 'r');
+    try {
+      const buf = Buffer.alloc(size - from);
+      fs.readSync(fd, buf, 0, buf.length, from);
+      lines = buf.toString('utf8').split('\n');
+      if (from > 0) lines.shift();
+    } finally { fs.closeSync(fd); }
   } catch { /* empty so far */ }
   return {
     id: job.id, command: job.command, running: job.exit === null, exit: job.exit,
@@ -75,11 +86,27 @@ export function stopBackground(id) {
   const job = findJob(id);
   if (!job) return false;
   if (job.exit !== null) return true;
+  killJob(job);
+  return true;
+}
+
+// The whole tree. On Windows child.kill() ended only cmd.exe: the dev server it started
+// kept running and holding its port while the tool said "Stopped".
+function killJob(job) {
+  const pid = job.child?.pid;
+  if (!pid) return;
   try {
-    job.child?.kill();
-    if (job.child?.pid && process.platform !== 'win32') {
-      try { process.kill(-job.child.pid); } catch { /* already gone */ }
-    }
+    if (process.platform === 'win32') spawnSync('taskkill', ['/pid', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+    else { try { process.kill(-pid, 'SIGTERM'); } catch { job.child.kill('SIGTERM'); } }
   } catch { /* already gone */ }
-  return true;
 }
+
+/**
+ * Stop every job still running. Called when Jaitus exits: jobs used to outlive it, and
+ * after a restart nothing could see or stop them — a dev server holding a port with no
+ * way back to it.
+ */
+export function stopAllBackground() {
+  for (const job of jobs.values()) if (job.exit === null) killJob(job);
+}
+process.once('exit', stopAllBackground);

package/src/commands/commit.js

@@ -1,71 +1,88 @@
 // ─── /commit — review the diff, write a real message, land it ───────────────────
 //
-// Shows what changed, asks the model to summarise the WHY into a subject line,
-// then commits. Pushing is always a separate confirmation — never implicit.
+// Shows what changed, asks the model to summarise the WHY into a subject line, then
+// asks before committing. Pushing is always a separate, explicit choice — never implicit.
+//
+//   /commit                    the model proposes a subject; you confirm
+//   /commit fix the login bug  your subject, used as written; you still confirm
+//
+// The previous version could never commit through its normal path: it did not await
+// its own prompts (so the answer was a Promise, never 'y'), read the subject from a
+// field the agent does not return, and ran git in the process directory rather than the
+// session's --cwd.
 import { spawnSync } from 'node:child_process';
 import { runAgent } from '../agent/loop.js';
 import { createPermissions } from '../agent/permissions.js';
 import { c, out, ok, warn, fail, askKey, glyph } from '../ui.js';
 
-function git(args, opts = {}) {
-  const r = spawnSync('git', args, { encoding: 'utf8', ...opts });
+function git(args, cwd) {
+  const r = spawnSync('git', args, { encoding: 'utf8', cwd, windowsHide: true });
   return { ok: r.status === 0, out: (r.stdout || '').trim(), err: (r.stderr || '').trim() };
 }
 
+/** A choice, through the app's dialog when there is one, else a key prompt. */
+async function choose(ctx, question, options) {
+  if (ctx.tui?.askDialog) {
+    const r = await ctx.tui.askDialog(question, options.map(([value, label]) => ({ value, label })), [], { title: 'COMMIT', hideComment: true });
+    return r && typeof r === 'object' ? r.value : r;
+  }
+  if (!process.stdin.isTTY) return null;
+  const keys = options.map(([value]) => value[0]);
+  const key = await askKey(`  ${question} ${options.map(([v, l]) => `(${v[0]}) ${l}`).join(' / ')}`, keys);
+  return options.find(([value]) => value[0] === key)?.[0] ?? null;
+}
+
 export default async function commit(args, ctx) {
-  if (!git(['rev-parse', '--is-inside-work-tree']).ok) {
+  const cwd = ctx.flags?.cwd || process.cwd();
+  if (!git(['rev-parse', '--is-inside-work-tree'], cwd).ok) {
     fail('Not a git repository.');
     return null;
   }
-  const status = git(['status', '--porcelain']);
+  const status = git(['status', '--porcelain'], cwd);
   if (!status.out) { ok('Nothing to commit — the working tree is clean.'); return null; }
 
-  // What the commit would contain, shown before anything happens.
-  const stat = git(['diff', '--stat', 'HEAD']).out || '';
-  if (stat) {
-    out(c.dim('  Changes:'));
-    for (const line of stat.split('\n').slice(0, 20)) out(`  ${c.dim(line)}`);
-    const n = stat.split('\n').length - 20;
-    if (n > 0) out(c.dim(`  ${glyph('…', '...')} and ${n} more files`));
-  }
-
-  // The model writes the message from the actual diff — with a firm brevity
-  // leash, because left alone every model writes essays.
-  let subject = '';
-  try {
-    const diff = git(['diff', 'HEAD']).out.slice(0, 12000);
-    const side = await runAgent({
-      client: ctx.client, cwd: ctx.flags.cwd,
-      permissions: createPermissions({ mode: 'plan' }),
-      messages: [{ role: 'user', content: `Write a git commit subject for this diff. Rules: imperative mood, no prefix, max 72 chars, say WHAT changed and WHY. Answer with the subject line ONLY — no quotes, no body, no markdown.\n\n${diff}` }],
-    });
-    const text = (side?.messages || []).filter((m) => m.role === 'assistant').pop();
-    const content = Array.isArray(text?.content) ? text.content.filter((b) => b.type === 'text').map((b) => b.text).join(' ') : (text?.content || '');
-    subject = content.trim().split('\n')[0].replace(/^["'`]|["'`]$/g, '').slice(0, 72);
-  } catch { /* fall through to the manual path */ }
+  // What the commit would contain, shown before anything happens — including files git
+  // does not track yet, which `git add -A` below will add.
+  const lines = status.out.split('\n');
+  out(c.dim(`  ${lines.length} file${lines.length === 1 ? '' : 's'} changed:`));
+  for (const line of lines.slice(0, 20)) out(`  ${c.dim(line)}`);
+  if (lines.length > 20) out(c.dim(`  ${glyph('…', '...')} and ${lines.length - 20} more`));
 
-  const typed = subject || '';
-  out(`  ${c.dim('Subject:')} ${c.bold(typed || '(write your own below)')}`);
-  const answer = askKey('  Commit with this message? (y)es / (e)dit / (n)o', ['y', 'e', 'n']);
-  if (answer === 'n') { warn('Commit cancelled.'); return null; }
-
-  let message = typed;
-  if (answer === 'e' || !typed) {
-    const editorMsg = git(['commit', '--dry-run', '--allow-empty'], {});
-    message = process.env.JAITUS_COMMIT_MSG || typed;
-    if (!message) { warn('No message — commit cancelled.'); return null; }
+  let subject = args.join(' ').trim();
+  if (!subject) {
+    // The model writes the message from the actual diff — with a firm brevity leash,
+    // because left alone every model writes essays.
+    const diff = git(['diff', 'HEAD'], cwd).out.slice(0, 12000) || status.out;
+    let text = '';
+    const messages = [{ role: 'user', content: `Write a git commit subject for this change. Rules: imperative mood, no prefix, max 72 chars, say WHAT changed and WHY. Answer with the subject line ONLY — no quotes, no body, no markdown.\n\n${diff}` }];
+    try {
+      if (ctx.runSide) await ctx.runSide({ messages, mode: 'plan', onText: (t) => { text += t; } });
+      else await runAgent({ client: ctx.client, model: ctx.model, cwd, permissions: createPermissions({ mode: 'plan' }), messages, silent: true, onText: (t) => { text += t; } });
+    } catch (e) {
+      warn(`Could not write a subject (${e.message}). Give one yourself: /commit <subject>`);
+      return null;
+    }
+    subject = text.trim().split('\n')[0].replace(/^["'`]|["'`]$/g, '').slice(0, 72);
+    if (!subject) { warn('No subject came back. Give one yourself: /commit <subject>'); return null; }
   }
 
-  const add = git(['add', '-A']);
+  out(`  ${c.dim('Subject:')} ${c.bold(subject)}`);
+  const answer = await choose(ctx, `Commit ${lines.length} file${lines.length === 1 ? '' : 's'} as "${subject}"?`, [
+    ['commit', 'Commit'],
+    ['push', 'Commit and push'],
+    ['no', 'Cancel'],
+  ]);
+  if (answer !== 'commit' && answer !== 'push') { warn('Commit cancelled. To use your own subject: /commit <subject>'); return null; }
+
+  const add = git(['add', '-A'], cwd);
   if (!add.ok) { fail(`Could not stage: ${add.err}`); return null; }
-  const done = git(['commit', '-m', message]);
+  const done = git(['commit', '-m', subject], cwd);
   if (!done.ok) { fail(`Commit failed: ${done.err || done.out}`); return null; }
-  ok(`Committed: ${message}`);
+  ok(`Committed: ${subject}`);
 
-  const push = askKey('  Push now? (y/N)', ['y', 'n']);
-  if (push === 'y') {
-    const branch = git(['branch', '--show-current']).out || 'main';
-    const pushed = git(['push', 'origin', branch]);
+  if (answer === 'push') {
+    const branch = git(['branch', '--show-current'], cwd).out || 'main';
+    const pushed = git(['push', 'origin', branch], cwd);
     if (pushed.ok) ok(`Pushed to origin/${branch}.`);
     else fail(`Push failed: ${pushed.err || pushed.out}`);
   }

package/src/commands/doctor.js

@@ -108,7 +108,7 @@ export default async function doctor(argv = [], { json = false } = {}) {
   // ── The account ───────────────────────────────────────────────────────────────
   if (key && reachable) {
     try {
-      const res = await reach(`${baseUrl}/api/auth/me`, { headers: { 'x-api-key': key } });
+      const res = await reach(`${baseUrl}/api/auth/me`, { headers: { authorization: `Bearer ${key}` } });
       const body = await res.json().catch(() => ({}));
       const u = body.user || body.data || {};
       if (res.ok && (u.email || u.id)) {

package/src/commands/explain.js

@@ -24,10 +24,10 @@ export default async function explain(args, ctx) {
       : `Explain the concept "${topic}" grounded in this project where it applies — read files to find real usages rather than answering abstractly. Keep it under 250 words.`;
 
   const sideMessages = [{ role: 'user', content: brief }];
-  const side = await runAgent({
-    client: ctx.client, messages: sideMessages, model: ctx.model, cwd: ctx.flags.cwd,
-    permissions: createPermissions({ mode: 'plan' }),
-    extraSystem: `You are the Jaitus explainer. Read-only: never edit files or run commands. Show file:line references for every claim about the code. Prefer short paragraphs over walls of text.`,
-  });
+  const extraSystem = `You are the Jaitus explainer. Read-only: never edit files or run commands. Show file:line references for every claim about the code. Prefer short paragraphs over walls of text.`;
+  // In the app: the transcript, Esc stops it, the session's own rules (see runSide).
+  const side = ctx.runSide
+    ? await ctx.runSide({ messages: sideMessages, mode: 'plan', extraSystem })
+    : await runAgent({ client: ctx.client, messages: sideMessages, model: ctx.model, cwd: ctx.flags.cwd, permissions: createPermissions({ mode: 'plan' }), extraSystem });
   return null;
 }

package/src/commands/logout.js

@@ -12,6 +12,8 @@ import { ok, info, warn } from '../ui.js';
 export default async function logout() {
   const { hadSession, server } = await signOut();
   if (!hadSession) {
+    // JAITUS_TOKEN signs every request by itself, so "not signed in" was untrue with it.
+    if (process.env.JAITUS_TOKEN) { info('This terminal signs in with JAITUS_TOKEN. Unset that variable to sign out; there is no saved sign-in to remove.'); return 0; }
     info('You were not signed in.');
     return 0;
   }

package/src/commands/research.js

@@ -48,12 +48,11 @@ export default async function research(args, ctx) {
   ].join('\n');
 
   const sideMessages = [{ role: 'user', content: brief }];
-  const sidePermissions = createPermissions({ mode: 'plan' }); // read-only: web tools only
-  const side = await runAgent({
-    client: ctx.client, messages: sideMessages, model: ctx.model, cwd: ctx.flags.cwd,
-    permissions: sidePermissions,
-    extraSystem: `You are the Jaitus research agent. You find things out on the web and report back with sources. You never edit files or run commands — web_search and web_fetch only. Be precise about what a source actually says; never invent a URL.`,
-  });
+  const sidePermissions = createPermissions({ mode: 'plan', allow: ['web_fetch'] }); // read-only: web tools only
+  const extraSystem = `You are the Jaitus research agent. You find things out on the web and report back with sources. You never edit files or run commands — web_search and web_fetch only. Be precise about what a source actually says; never invent a URL.`;
+  const side = ctx.runSide
+    ? await ctx.runSide({ messages: sideMessages, mode: 'plan', extraSystem, allow: ['web_fetch'] })
+    : await runAgent({ client: ctx.client, messages: sideMessages, model: ctx.model, cwd: ctx.flags.cwd, permissions: sidePermissions, extraSystem });
 
   ok(`Research complete (${side.tools || 0} tool calls, ${((side.input || 0) + (side.output || 0)).toLocaleString()} tokens).`);
   return null;

package/src/commands/review.js

@@ -64,17 +64,14 @@ export async function runReview(mode, args, ctx) {
     role: 'user',
     content: `${brief.task(target)}\n\nDiff${target ? ` (${target})` : ''}:\n${diff.out.slice(0, 30000)}${diff.out.length > 30000 ? `\n${glyph('…', '...')}(truncated)` : ''}`,
   }];
-  await runAgent({
-    client: ctx.client, messages, model: ctx.model, cwd: ctx.flags.cwd,
-    // Reviewing reads; --fix writes — so the fix pass inherits the session's
-    // own permission mode instead of smuggling in a permissive one.
-    permissions: fix
-      ? createPermissions({ mode: ctx.permissions?.mode || 'default' })
-      : createPermissions({ mode: 'plan' }),
-    extraSystem: fix
-      ? `${brief.system}\n\nAfter reporting, APPLY the fixes you recommended (minimal diffs, same style as the file). Then summarize what changed.`
-      : brief.system,
-  });
+  // Reviewing reads; --fix writes — so the fix pass inherits the session's own
+  // permission mode AND its allow/deny rules instead of smuggling in fresh ones.
+  const runMode = fix ? (ctx.permissions?.mode || 'default') : 'plan';
+  const extraSystem = fix
+    ? `${brief.system}\n\nAfter reporting, APPLY the fixes you recommended (minimal diffs, same style as the file). Then summarize what changed.`
+    : brief.system;
+  if (ctx.runSide) await ctx.runSide({ messages, mode: runMode, extraSystem });
+  else await runAgent({ client: ctx.client, messages, model: ctx.model, cwd: ctx.flags.cwd, permissions: createPermissions({ mode: runMode }), extraSystem });
   if (!fix) warn(`Run with --fix to let the agent apply the findings (permissions still ask first).`);
   return null;
 }

package/src/commands/test.js

@@ -6,7 +6,6 @@
 // only after permission, and re-runs until green or you stop it.
 //
 // Usage: /test [anything forwarded to the runner]
-import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { ok, warn, fail, out, c } from '../ui.js';
@@ -33,18 +32,25 @@ export default async function test(args, ctx) {
   const runner = detectRunner(ctx.flags.cwd);
   if (!runner) { warn('No test runner found (package.json scripts, pytest, go, cargo).'); return null; }
 
-  out(c.dim(`  Running: ${runner.label}${forward.length ? ` ${forward.join(' ')}` : ''}`));
-  const r = spawnSync(runner.cmd, [...runner.args, ...forward], {
-    cwd: ctx.flags.cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
-  });
-  const output = `${r.stdout || ''}\n${r.stderr || ''}`.trim();
+  const command = [runner.cmd, ...runner.args, ...forward].join(' ');
+  out(c.dim(`  Running: ${command}  (Esc stops it)`));
+  // Through the same runner as the agent's commands: a shell (on Windows `npm` is
+  // npm.cmd, and spawnSync without one failed every time — "Tests failed (exit null)"),
+  // the whole process tree killed on Esc or at the limit, output capped — and it no
+  // longer freezes the interface while the suite runs.
+  const { byName } = await import('../agent/tools.js');
+  const run = (signal) => byName.run_command.run({ command, timeout_ms: 600_000 }, { cwd: ctx.flags.cwd, signal });
+  const output = String(ctx.abortable ? await ctx.abortable(run) : await run(null));
+  const status = Number((/exit code: (\d+)/.exec(output) || [])[1]);
+  const body = output.replace(/\n*exit code: .*$/s, '');
 
   // Show the tail — enough to see failures, not the whole log.
-  const lines = output.split('\n');
+  const lines = body.split('\n');
   for (const line of lines.slice(-40)) out(`  ${line}`);
 
-  if (r.status === 0) { ok('All tests passed.'); return null; }
-  fail(`Tests failed (exit ${r.status}).`);
+  if (/\[stopped by the user\]/.test(output)) { warn('Test run stopped.'); return null; }
+  if (status === 0) { ok('All tests passed.'); return null; }
+  fail(`Tests failed (exit ${Number.isFinite(status) ? status : 'none'}).`);
 
   if (!wantsFix) {
     warn('Run /test --fix to let the agent fix the failures.');
@@ -59,10 +65,8 @@ export default async function test(args, ctx) {
     role: 'user',
     content: `These tests are failing in ${ctx.flags.cwd}. Diagnose and FIX them: read the failing code, make the minimal correct changes, then run \`${runner.label}\` again. Do not weaken assertions to make tests pass unless the test itself is provably wrong.\n\nFailure output (tail):\n${output.slice(-12000)}`,
   }];
-  await runAgent({
-    client: ctx.client, messages: fixMessages, model: ctx.model, cwd: ctx.flags.cwd,
-    permissions: createPermissions({ mode: ctx.permissions?.mode || 'default' }),
-    extraSystem: `You are fixing failing tests. Minimal, correct changes. Never delete a failing test to go green; fix the code (or fix the test only if the test is wrong).`,
-  });
+  const extraSystem = `You are fixing failing tests. Minimal, correct changes. Never delete a failing test to go green; fix the code (or fix the test only if the test is wrong).`;
+  if (ctx.runSide) await ctx.runSide({ messages: fixMessages, mode: ctx.permissions?.mode || 'default', extraSystem });
+  else await runAgent({ client: ctx.client, messages: fixMessages, model: ctx.model, cwd: ctx.flags.cwd, permissions: createPermissions({ mode: ctx.permissions?.mode || 'default' }), extraSystem });
   return null;
 }

package/src/config.js

@@ -75,8 +75,19 @@ export function loadSettings() {
   return readJson(SETTINGS, {});
 }
 
+// Whoever is showing settings live (the app view) is told when they change. /scroll-speed,
+// /animations, /config mouse and copyOnSelect used to say "saved" and do nothing until a
+// restart, because the app had read them once at start.
+const settingsListeners = new Set();
+export function onSettingsChange(fn) {
+  settingsListeners.add(fn);
+  return () => settingsListeners.delete(fn);
+}
+
 export function saveSettings(settings) {
-  writeJson(SETTINGS, settings, 0o644);
+  // 0600: it can hold search API keys (braveSearchKey, tavilyKey, serperKey).
+  writeJson(SETTINGS, settings, 0o600);
+  for (const fn of settingsListeners) { try { fn(settings); } catch { /* a listener never breaks a save */ } }
 }
 
 /**

package/src/errors.js

@@ -17,6 +17,10 @@ const CATALOG = {
   plan_limit_reached: { title: 'Monthly allowance used', hint: 'It resets at the start of your next period, or upgrade on the website. /usage shows where you are.' },
   rate_limited: { title: 'Slow down', hint: 'Wait a moment, then retry.' },
   context_too_long: { title: 'Conversation too long', hint: 'Run /compact, or start a new session.' },
+  request_too_large: { title: 'Request too large', hint: 'Usually images: remove some, or run /compact to drop old ones. Images over 3.5 MB are shrunk automatically.' },
+  daily_limit_reached: { title: 'Daily limit reached', hint: 'Your plan\'s daily allowance resets tomorrow. /usage shows where you are.' },
+  token_expired: { title: 'Signed out', hint: 'Type /login to sign in again (or run `jaitus login`).' },
+  refresh_race: { title: 'Sign-in was being renewed', hint: 'Try again.' },
   content_blocked: { title: 'Request refused', hint: 'Rephrase the request and try again.' },
   bad_request: { title: 'Request not accepted', hint: 'Try again; if it repeats, run /debug and contact support.' },
   model_unavailable: { title: 'Model unavailable', hint: 'Run /model to pick another.' },