wisp-agents 0.15.0 → 0.17.0

package/server/routes/internal.js

@@ -0,0 +1,176 @@
+// Bridge for the MCP servers running inside an agent process (ask_user, approve, delegate, wisp_stats,
+// wisp_sessions, wisp_session). Every call
+// carries the per-run token wisp handed the agent; nothing else may use these.
+
+import { adapters } from '../adapters/index.js';
+import { plainMentions } from '../mentions.js';
+import { blocksToMarkdown, sessionToMarkdown } from '../render.js';
+import { summarize } from '../runner.js';
+import { delegationReport } from '../subagents.js';
+import { toolStats, toolStatsText } from '../usage.js';
+import { clip } from '../util.js';
+
+export function register(r, app) {
+  const { store, runner, telemetry } = app;
+  // The token check, then the handler; a wrong token is a 403 whatever the route.
+  const guarded = (fn) => (c) => (c.req.headers['x-wisp-token'] !== app.token ? c.send(403, { error: 'bad token' }) : fn(c));
+  const opts = { doc: false };
+  const lead = (c) => store.get(c.params.id);
+
+  r.route(
+    'POST',
+    '/internal/ask',
+    guarded(async (c) => {
+      const body = await c.body();
+      const s = store.get(body.session);
+      if (!s) return c.send(404, { error: 'no such session' });
+      telemetry.track('ask_user', { agent: s.agent });
+      c.send(200, { id: runner.ask(s, body) });
+    }),
+    opts,
+  );
+  r.route('GET', '/internal/ask/:id', guarded((c) => c.send(200, runner.pollAnswer(c.params.id))), opts);
+
+  // A live approval (the harness's permission prompt): { decision } at once, or an { id } to poll
+  // like ask_user, whose answer carries the decision.
+  r.route(
+    'POST',
+    '/internal/approve',
+    guarded(async (c) => {
+      const body = await c.body();
+      const s = store.get(body.session);
+      if (!s) return c.send(404, { error: 'no such session' });
+      const out = runner.requestApproval(s, body);
+      if (out.id) telemetry.track('approval', { agent: s.agent });
+      c.send(200, out);
+    }),
+    opts,
+  );
+
+  // delegate: POST starts tasks on the lead's subagents; GET reports on them (done once all finished).
+  r.route(
+    'POST',
+    '/internal/delegate/:id',
+    guarded(async (c) => {
+      const s = lead(c);
+      if (!s) return c.send(404, { error: 'no such session' });
+      const body = await c.body();
+      const delegations = runner.delegate(s, body.tasks);
+      telemetry.track('delegate', { agent: s.agent, tasks: delegations.length, harnesses: [...new Set(delegations.filter((d) => d.agent).map((d) => d.agent))] });
+      c.send(200, { delegations });
+    }),
+    opts,
+  );
+  r.route(
+    'GET',
+    '/internal/delegate/:id',
+    guarded((c) => {
+      const s = lead(c);
+      if (!s) return c.send(404, { error: 'no such session' });
+      const ids = (c.query.get('ids') || '').split(',').filter(Boolean);
+      const list = runner.delegations(s, ids);
+      if (!list.length) return c.send(200, { done: true, text: 'No delegated tasks to report on.' });
+      const running = ({ d, child }) => child?.turns.find((t) => t.id === d.turnId)?.status === 'running';
+      c.send(200, { done: !list.some(running), text: list.map(({ d, child }) => delegationReport(d, child, adapters)).join('\n\n---\n\n') });
+    }),
+    opts,
+  );
+
+  // wisp_stats: read-only tool counts, spend and success across sessions. project=current is the
+  // asking session's project.
+  r.route(
+    'GET',
+    '/internal/stats/:id',
+    guarded((c) => {
+      const s = lead(c);
+      if (!s) return c.send(404, { error: 'no such session' });
+      const projectFor = (x) => store.projectFor(x.cwd);
+      let project = c.query.get('project') || '';
+      if (project === 'current') project = projectFor(s)?.id || String(s.cwd || '').split(/[\\/]/).pop();
+      const stats = toolStats(store.all(), { days: Number(c.query.get('days')) || 30, project: projectFor, filter: { agent: c.query.get('agent') || '', project } });
+      telemetry.track('wisp_stats', { agent: s.agent });
+      c.send(200, { stats, text: toolStatsText(stats) });
+    }),
+    opts,
+  );
+  // wisp_sessions: the user's other tasks (not the asker, its subagents or the tour), newest first.
+  r.route(
+    'GET',
+    '/internal/sessions/:id',
+    guarded((c) => {
+      const s = lead(c);
+      if (!s) return c.send(404, { error: 'no such session' });
+      const q = Object.fromEntries(c.query);
+      let project = q.project || '';
+      if (project === 'current') project = store.projectFor(s.cwd)?.id || String(s.cwd || '').split(/[\\/]/).pop();
+      const states = q.state ? q.state.split(',').map((x) => x.trim()) : null;
+      const words = String(q.query || '').toLowerCase().split(/\s+/).filter(Boolean);
+      const all = store
+        .all()
+        .filter((x) => x.id !== s.id && !x.parentId && x.agent !== 'wisp' && x.id !== s.parentId)
+        .map((x) => summarize(x, store))
+        .filter((x) => (q.archived === 'true' || !x.archived) && (!states || states.includes(x.state)))
+        .filter((x) => !project || x.projectId === project || x.project === project)
+        .filter((x) => words.every((w) => `${x.title} ${x.preview}`.toLowerCase().includes(w)))
+        .sort((a, b) => b.updatedAt - a.updatedAt);
+      const list = all.slice(0, Math.min(Math.max(Number(q.limit) || 20, 1), 100));
+      telemetry.track('wisp_sessions', { agent: s.agent });
+      const text = list.length
+        ? `${all.length} task${all.length === 1 ? '' : 's'}${all.length > list.length ? `, the newest ${list.length}` : ''}. Read one with wisp_session.\n\n${list.map(sessionLine).join('\n')}`
+        : 'No tasks match.';
+      c.send(200, { text });
+    }),
+    opts,
+  );
+
+  // wisp_session: one task's requests and a turn's report (?of=<id>&turn=<1-based>).
+  r.route(
+    'GET',
+    '/internal/session/:id',
+    guarded((c) => {
+      const s = lead(c);
+      if (!s) return c.send(404, { error: 'no such session' });
+      const id = String(c.query.get('of') || '').trim().replace(/^wisp:/, '');
+      const x = store.get(id);
+      telemetry.track('wisp_session', { agent: s.agent });
+      if (!x) return c.send(200, { text: `No wisp task \`${id}\` on this computer. It may have been deleted, or it ran on another machine. List tasks with wisp_sessions.` });
+      c.send(200, { text: sessionText(x, store, c.query.get('turn')) });
+    }),
+    opts,
+  );
+}
+
+const age = (t) => {
+  const m = Math.round((Date.now() - t) / 60_000);
+  return m < 1 ? 'just now' : m < 60 ? `${m}m ago` : m < 48 * 60 ? `${Math.round(m / 60)}h ago` : `${Math.round(m / 1440)}d ago`;
+};
+
+const sessionLine = (x) =>
+  `- \`${x.id}\` **${x.title}** — ${x.archived ? 'archived, ' : ''}${x.state}, ${x.agent}${x.model ? ` (${x.model})` : ''}, ${x.project}, ${age(x.updatedAt)}${x.state === 'running' && x.live ? `: ${x.live}` : x.preview ? `: ${clip(x.preview, 160)}` : ''}`;
+
+export function sessionText(x, store, turnArg) {
+  const sum = summarize(x, store);
+  const n = Number(turnArg);
+  const turn = turnArg === null || turnArg === undefined || turnArg === '' || !n ? x.turns.at(-1) : x.turns[n - 1];
+  const head = [
+    `# ${x.title}`,
+    `Task \`${x.id}\` · ${sum.archived ? 'archived · ' : ''}${x.state} · ${x.agent}${x.model ? ` (${x.model})` : ''} · project ${sum.project} · updated ${age(x.updatedAt)}`,
+    `Folder: \`${x.worktree?.path || x.cwd}\`${x.worktree ? ` (worktree, branch \`${x.worktree.branch}\`)` : ''}${x.pr ? ` · PR #${x.pr.number} (${String(x.pr.state).toLowerCase()}): ${x.pr.url}` : ''}`,
+  ];
+  const asks = x.turns.map((t, i) => `${i + 1}. ${clip(plainMentions(t.prompt).replace(/\s+/g, ' '), 300)}${t.status === 'running' ? ' _(running)_' : t.status === 'error' ? ' _(failed)_' : t.status === 'stopped' ? ' _(stopped)_' : ''}`);
+  if (!turn) return [...head, '', `Turn ${turnArg} doesn't exist; this task has ${x.turns.length}.`, '', '## Requests', ...asks].join('\n');
+  const i = x.turns.indexOf(turn);
+  const report = turn === x.turns.at(-1) ? sessionToMarkdown(x) : blocksToMarkdown(turn.presentation?.blocks, turn);
+  const files = (turn.changes || []).filter((ch) => !ch.reverted).map((ch) => `\`${ch.file}\``);
+  return [
+    ...head,
+    '',
+    `## Requests (${x.turns.length})`,
+    ...asks,
+    '',
+    `## Report for turn ${i + 1}${x.turns.length > 1 ? ` of ${x.turns.length} (pass turn to read another)` : ''}`,
+    '',
+    report || '_No report yet._',
+    ...(files.length ? ['', `Files edited in this turn: ${files.join(', ')}`] : []),
+  ].join('\n');
+}

package/server/routes/machines.js

@@ -0,0 +1,43 @@
+// /api/machines: add, connect, and browse folders on other computers.
+
+import { sshHosts, discoverHosts } from '../machines.js';
+
+export function register(r, app) {
+  const { store, machines } = app;
+  const one = (mid) => machines.view().find((x) => x.id === mid);
+  // A machine route: 404s for an unknown id before doing anything.
+  const known = (fn) => (c) => (machines.get(c.params.id), fn(c, c.params.id));
+
+  r.route('GET', '/machines', (c) => c.send(200, machines.view()));
+  r.route('POST', '/machines', async (c) => {
+    const body = await c.body();
+    const x = machines.add(body);
+    if (body.connect !== false) await machines.connect(x.id);
+    c.send(201, one(x.id));
+  });
+  r.route('GET', '/machines/ssh-hosts', (c) => c.send(200, sshHosts()));
+  r.route('GET', '/machines/discover', async (c) => c.send(200, await discoverHosts()));
+  r.route('PATCH', '/machines/:id', known(async (c, id) => c.send(200, (await machines.update(id, await c.body()), one(id)))));
+  r.route(
+    'DELETE',
+    '/machines/:id',
+    known((c, id) => {
+      machines.remove(id);
+      app.broadcast('config', {});
+      c.send(200, { ok: true });
+    }),
+  );
+  r.route('POST', '/machines/:id/connect', known(async (c, id) => c.send(200, await machines.connect(id))));
+  r.route('POST', '/machines/:id/disconnect', known((c, id) => c.send(200, (machines.disconnect(id), one(id)))));
+  // Stop wisp over there (its agents too); restart starts this version in its place.
+  r.route('POST', '/machines/:id/stop', known(async (c, id) => c.send(200, (await machines.stopRemote(id, { restart: !!(await c.body()).restart }), one(id)))));
+  r.route('GET', '/machines/:id/fs', known(async (c, id) => c.send(200, await machines.json(id, 'GET', `/fs?q=${encodeURIComponent(c.query.get('q') || '')}`))));
+  r.route(
+    'GET',
+    '/machines/:id/discover',
+    known(async (c, id) => {
+      const have = new Set(store.config.projects.filter((p) => p.machine === id).map((p) => p.path));
+      c.send(200, (await machines.json(id, 'GET', '/projects/discover')).filter((f) => !have.has(f.path)));
+    }),
+  );
+}

package/server/routes/meta.js

@@ -0,0 +1,76 @@
+// The server itself: live events, health, self-update, the API description, installed
+// harnesses, folder suggestions, usage and feedback.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { openapi } from '../openapi.js';
+import { usage } from '../usage.js';
+import { expandHome, VERSION } from '../util.js';
+
+export const API_VERSION = 1;
+
+export function register(r, app) {
+  const { store, runner, updater, telemetry, machines, port } = app;
+
+  r.route('GET', '/events', (c) => app.events.attach(c.req, c.res));
+
+  r.route('GET', '/health', (c) => c.send(200, { ok: true, name: 'wisp', version: VERSION, apiVersion: API_VERSION, pid: process.pid, url: `http://127.0.0.1:${port}` }));
+
+  // New wisp-agents on npm? POST installs it and relaunches; running agents are stopped, so the
+  // client must pass force once it has confirmed that with the user.
+  r.route('GET', '/update', async (c) => {
+    if (c.query.has('check')) return c.send(200, await updater.check());
+    updater.maybeCheck(); // the UI asks on focus and reconnect: a day-old check gets refreshed
+    c.send(200, updater.view());
+  });
+  r.route('POST', '/update', async (c) => {
+    const body = await c.body();
+    if (runner.live.size && !body.force) return c.send(409, { error: 'agents are running', running: runner.live.size });
+    await updater.install();
+    c.send(202, updater.view());
+    telemetry.track('update', { from: updater.state.current, to: updater.state.latest, method: updater.method });
+    setTimeout(() => (app.shutdown(), process.exit(0)), 300);
+  });
+
+  r.route('GET', '/openapi.json', (c) => c.send(200, openapi({ version: VERSION, port })), { doc: false });
+
+  r.route('GET', '/agents', async (c) => c.send(200, await app.auto.detect({ fresh: c.query.has('fresh') })));
+  // Re-check: detect harnesses and models again, here and on every online machine.
+  r.route('POST', '/agents/recheck', async (c) => {
+    const [agents] = await Promise.all([app.auto.detect({ fresh: true }), machines.recheckAgents()]);
+    c.send(200, agents);
+  });
+  // No harness yet: install one (opencode) without leaving wisp. Answers once it's ready.
+  r.route('POST', '/agents/install', async (c) => {
+    const { id } = await c.body();
+    c.send(200, await app.installer.run(String(id || '')));
+  });
+
+  // Directory suggestions for the launcher's project picker.
+  r.route(
+    'GET',
+    '/fs',
+    (c) => {
+      const raw = expandHome(c.query.get('q') || '');
+      const trailing = /[\\/]$/.test(raw); // a trailing backslash counts too (Windows)
+      const dir = trailing ? raw : path.dirname(raw);
+      const prefix = trailing ? '' : path.basename(raw).toLowerCase();
+      let entries = [];
+      try {
+        entries = fs
+          .readdirSync(dir, { withFileTypes: true })
+          .filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name.toLowerCase().startsWith(prefix))
+          .slice(0, 12)
+          .map((e) => path.join(dir, e.name));
+      } catch {}
+      c.send(200, entries);
+    },
+    { doc: false },
+  );
+
+  // Spend and outcomes. ?days=7|30|90
+  r.route('GET', '/usage', (c) => c.send(200, usage(store.all(), { days: Number(c.query.get('days')) || 30, project: (s) => store.projectFor(s.cwd) })));
+
+  // Feedback for the wisp team: thumbs on a turn and/or a note. { rating?, text?, sessionId?, turnId? }
+  r.route('POST', '/feedback', async (c) => c.send(200, await app.sendFeedback(await c.body())));
+}

package/server/routes/proxy.js

@@ -0,0 +1,47 @@
+// /api/sessions/<id>@<machine>/…: passed through to that machine's wisp, ids rewritten.
+// Registered before the session routes, so a qualified id never reaches them.
+
+import os from 'node:os';
+import { pipeFrom } from '../http/respond.js';
+import { splitId, qualify } from '../machines.js';
+import { openInTerminal, shq } from '../terminal.js';
+import { MAX_WAIT_S } from './sessions.js';
+
+const METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+
+export function register(r, app) {
+  const { store, machines, telemetry } = app;
+  const remote = { when: (p) => !!splitId(p.id), doc: false };
+
+  async function proxy(c) {
+    const at = splitId(c.params.id);
+    const { action } = c.params;
+    const m = c.req.method;
+    const mid = at.machine;
+    const sub = `/sessions/${at.id}${action ? `/${action}` : ''}${c.url.search}`;
+    if ((action === 'file' && m === 'GET') || (action === 'presentation' && c.query.get('format') === 'markdown')) return pipeFrom(c.res, await machines.stream(mid, 'GET', sub));
+    // Take over: a terminal here, signed in over there, resuming the agent in its folder.
+    if (action === 'takeover') {
+      const { command } = await machines.json(mid, 'GET', `/sessions/${at.id}/takeover`);
+      const argv = machines.terminalArgv(mid, command);
+      if (m === 'POST') {
+        const s = await machines.json(mid, 'GET', `/sessions/${at.id}`);
+        if (s.state === 'running' || s.state === 'waiting') await machines.json(mid, 'POST', `/sessions/${at.id}/stop`, {});
+        const d = store.config.defaults;
+        openInTerminal({ cwd: os.homedir(), argv, terminal: d.terminal || 'auto', custom: d.terminalCommand });
+        telemetry.track('takeover', { agent: s.agent, terminal: d.terminal || 'auto', machine: true });
+      }
+      return c.send(200, { command: argv.map(shq).join(' ') });
+    }
+    const body = m === 'GET' ? undefined : await c.body();
+    if (action === 'reply' && body?.attachments?.length) body.attachments = await app.launcher.pushUploads(mid, body.attachments);
+    const out = await machines.json(mid, m, sub, body, action === 'wait' ? { timeout: (MAX_WAIT_S + 30) * 1000 } : undefined);
+    if (!action && m === 'GET') return c.send(200, machines.session(mid, out));
+    if ((!action && m === 'PATCH') || action === 'wait') return c.send(200, machines.summary(mid, out));
+    if (out && typeof out === 'object' && out.sessionId) out.sessionId = qualify(out.sessionId, mid);
+    c.send(200, out);
+  }
+
+  r.route(METHODS, '/sessions/:id', proxy, remote);
+  r.route(METHODS, '/sessions/:id/:action', proxy, remote);
+}