synabun 2.0.10 → 2.2.0

package/neural-interface/public/shared/agy/agy-client.js

@@ -0,0 +1,266 @@
+// ═══════════════════════════════════════════
+// SynaBun — Antigravity panel: the socket to /ws/antigravity (no DOM)
+// ═══════════════════════════════════════════
+//
+// `request(type, payload)` resolves with the server's `data` or rejects with an
+// Error carrying `code` and `authRequired`; every other message is an event for
+// `on(type, fn)`. The socket opens on the first request, says `hello` first (with
+// what `helloPayload()` returns: the panel's client capabilities), and opens again
+// (1 s, 2 s, 4 s … 30 s) after it drops while anything is still listening;
+// requests in flight when it drops reject with code 'DISCONNECTED'.
+//
+// A socket that never opens is not always a dropped connection: SynaBun refuses
+// /ws/antigravity to its own automation browser, a relay and invite guests (403
+// before the upgrade, which a page cannot see), and a server started before the
+// panel existed does not know the path at all. After two opens in a row that fail,
+// the client asks `probe()` (GET /api/antigravity/panel, refused or missing the same
+// way) and, when the answer says the socket will not open, stops trying and emits
+// `blocked { reason: 'automation' | 'refused' | 'guest' | 'restart', message }`
+// instead of going on forever. `reconnectNow()` tries again at once.
+// Events of its own: `connected` (hello), `disconnected`, `retrying { attempt, waitMs }`, `blocked`.
+// `WebSocketImpl`, `url` and `probe` are injectable, so this runs under `node --test`.
+
+const BACKOFF_MS = [1000, 2000, 4000, 8000, 15000, 30000];
+const PROBE_AFTER_FAILURES = 2;
+
+export function antigravitySocketUrl(location = globalThis.location) {
+  if (!location) return 'ws://127.0.0.1:3344/ws/antigravity';
+  const scheme = location.protocol === 'https:' ? 'wss:' : 'ws:';
+  return `${scheme}//${location.host}/ws/antigravity`;
+}
+
+/**
+ * What GET /api/antigravity/panel says about the socket: { reason: null } (it should open: keep trying),
+ * { reason: 'offline' } (SynaBun did not answer: keep trying), or a reason that stops the retries:
+ * 'restart' (the server predates the panel), 'automation' (SynaBun's automation browser), 'guest' (an invite
+ * guest), 'refused' (any other refusal: a relay, a proxy), each with the server's words in `message`.
+ */
+export function probeVerdict({ status = 0, body = null, failed = false } = {}) {
+  if (failed) return { reason: 'offline', message: '' };
+  if (status >= 200 && status < 300) return { reason: null, message: '' };
+  const code = String(body?.code || '');
+  const message = typeof body?.error === 'string' ? body.error : '';
+  if (status === 404) return { reason: 'restart', message };
+  if (status === 403 || status === 401) {
+    if (code === 'WORKER_BROWSER') return { reason: 'automation', message };
+    if (/GUEST|INVITE|ADMIN/i.test(code) || /guest/i.test(message)) return { reason: 'guest', message };
+    return { reason: 'refused', message };
+  }
+  if (status >= 500) return { reason: null, message };
+  return { reason: 'refused', message };
+}
+
+export async function defaultProbe(fetchImpl = globalThis.fetch) {
+  if (typeof fetchImpl !== 'function') return probeVerdict({ failed: true });
+  try {
+    const res = await fetchImpl('/api/antigravity/panel', { headers: { Accept: 'application/json' }, cache: 'no-store' });
+    let body = null;
+    try { body = await res.json(); } catch { body = null; }
+    return probeVerdict({ status: res.status, body });
+  } catch {
+    return probeVerdict({ failed: true });
+  }
+}
+
+export function createAntigravityClient({
+  url = antigravitySocketUrl(),
+  WebSocketImpl = globalThis.WebSocket,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+  requestTimeoutMs = 0,
+  helloPayload = () => ({}),
+  probe = () => defaultProbe(),
+} = {}) {
+  let ws = null;
+  let opening = null;
+  let hello = null;
+  let seq = 0;
+  let attempt = 0;
+  let failures = 0;          // opens in a row that closed before the hello
+  let reconnectTimer = null;
+  let disposed = false;
+  let blocked = null;        // { reason, message } once a probe said the socket will not open
+  let probing = null;
+  const pending = new Map();
+  const listeners = new Map();
+
+  function emit(type, payload) {
+    for (const fn of [...(listeners.get(type) || [])]) {
+      try { fn(payload); } catch (error) { console.error('[antigravity] listener failed', error); }
+    }
+    for (const fn of [...(listeners.get('*') || [])]) {
+      try { fn(type, payload); } catch (error) { console.error('[antigravity] listener failed', error); }
+    }
+  }
+
+  function failPending(code, message) {
+    for (const [reqId, entry] of [...pending]) {
+      pending.delete(reqId);
+      if (entry.timer) clearTimer(entry.timer);
+      entry.reject(Object.assign(new Error(message), { code }));
+    }
+  }
+
+  function onMessage(event) {
+    let message;
+    try { message = JSON.parse(typeof event.data === 'string' ? event.data : String(event.data)); } catch { return; }
+    if (!message || typeof message.type !== 'string') return;
+    if (message.type === 'result') {
+      const entry = pending.get(message.reqId);
+      if (!entry) return;
+      pending.delete(message.reqId);
+      if (entry.timer) clearTimer(entry.timer);
+      if (message.ok) entry.resolve(message.data);
+      else entry.reject(Object.assign(new Error(message.error?.message || 'Request failed'), { code: message.error?.code, data: message.error?.data, authRequired: !!message.authRequired }));
+      return;
+    }
+    emit(message.type, message);
+  }
+
+  const listening = () => [...listeners.values()].some((set) => set.size);
+
+  function scheduleReconnect() {
+    if (disposed || reconnectTimer || blocked || !listening()) return;
+    const wait = BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)];
+    attempt += 1;
+    emit('retrying', { attempt, waitMs: wait });
+    reconnectTimer = setTimer(() => {
+      reconnectTimer = null;
+      // A socket that closes schedules the next try itself (onclose → afterFailure); only a socket that could not
+      // even be made needs one from here.
+      open().catch((error) => { if (error?.code !== 'DISCONNECTED' && error?.code !== 'BLOCKED') scheduleReconnect(); });
+    }, wait);
+  }
+
+  // Two failed opens in a row: ask why before trying again.
+  async function afterFailure() {
+    if (failures < PROBE_AFTER_FAILURES || blocked || disposed) { scheduleReconnect(); return; }
+    if (!probing) probing = Promise.resolve().then(() => probe()).catch(() => ({ reason: 'offline', message: '' })).finally(() => { probing = null; });
+    const verdict = await probing;
+    if (disposed) return;
+    if (verdict?.reason && verdict.reason !== 'offline') {
+      blocked = { reason: verdict.reason, message: verdict.message || '' };
+      if (reconnectTimer) { clearTimer(reconnectTimer); reconnectTimer = null; }
+      emit('blocked', blocked);
+      return;
+    }
+    if (verdict?.reason === 'offline') emit('offline', {});
+    scheduleReconnect();
+  }
+
+  function rawSend(type, payload) {
+    const reqId = `q${++seq}`;
+    return new Promise((resolve, reject) => {
+      const entry = { resolve, reject, timer: null };
+      if (requestTimeoutMs > 0) {
+        entry.timer = setTimer(() => {
+          pending.delete(reqId);
+          reject(Object.assign(new Error(`${type} timed out`), { code: 'TIMEOUT' }));
+        }, requestTimeoutMs);
+      }
+      pending.set(reqId, entry);
+      try { ws.send(JSON.stringify({ ...payload, type, reqId })); } catch (error) {
+        pending.delete(reqId);
+        if (entry.timer) clearTimer(entry.timer);
+        reject(Object.assign(new Error(error?.message || 'Send failed'), { code: 'DISCONNECTED' }));
+      }
+    });
+  }
+
+  function open() {
+    if (disposed) return Promise.reject(Object.assign(new Error('Closed'), { code: 'DISPOSED' }));
+    if (blocked) return Promise.reject(Object.assign(new Error(blocked.message || 'The Antigravity connection was refused.'), { code: 'BLOCKED', reason: blocked.reason }));
+    if (ws && ws.readyState === 1 && hello) return Promise.resolve(hello);
+    if (opening) return opening;
+    if (typeof WebSocketImpl !== 'function') return Promise.reject(Object.assign(new Error('WebSockets are not available.'), { code: 'NO_WEBSOCKET' }));
+    opening = new Promise((resolve, reject) => {
+      let socket;
+      try { socket = new WebSocketImpl(url); } catch (error) { opening = null; reject(error); return; }
+      ws = socket;
+      let settled = false;
+      let opened = false;
+      socket.onmessage = onMessage;
+      socket.onopen = async () => {
+        opened = true;
+        try {
+          let payload = {};
+          try { payload = helloPayload() || {}; } catch { payload = {}; }
+          hello = await rawSend('hello', payload);
+          attempt = 0;
+          failures = 0;
+          settled = true;
+          opening = null;
+          emit('connected', hello);
+          resolve(hello);
+        } catch (error) {
+          settled = true;
+          opening = null;
+          reject(error);
+        }
+      };
+      socket.onclose = () => {
+        if (ws === socket) { ws = null; hello = null; }
+        failPending('DISCONNECTED', 'The connection to SynaBun dropped.');
+        if (!opened) failures += 1;
+        if (!settled) { settled = true; opening = null; reject(Object.assign(new Error('Could not connect to SynaBun.'), { code: 'DISCONNECTED' })); }
+        emit('disconnected', { opened });
+        if (listening()) afterFailure().catch(() => {});
+      };
+      socket.onerror = () => { /* onclose follows */ };
+    });
+    return opening;
+  }
+
+  async function request(type, payload = {}) {
+    await open();
+    return rawSend(type, payload);
+  }
+
+  /** Say hello again on the open socket (new client capabilities, or after an install): the new hello is `connected`. */
+  async function refreshHello(type = 'hello', payload = null) {
+    await open();
+    let body = payload;
+    if (!body) { try { body = helloPayload() || {}; } catch { body = {}; } }
+    const answer = await rawSend(type, body);
+    hello = answer;
+    emit('connected', answer);
+    return answer;
+  }
+
+  /** Try again now: forget a refusal, reset the back-off and open. */
+  function reconnectNow() {
+    blocked = null;
+    failures = 0;
+    attempt = 0;
+    if (reconnectTimer) { clearTimer(reconnectTimer); reconnectTimer = null; }
+    return open();
+  }
+
+  function on(type, fn) {
+    if (!listeners.has(type)) listeners.set(type, new Set());
+    listeners.get(type).add(fn);
+    return () => listeners.get(type)?.delete(fn);
+  }
+
+  function dispose() {
+    disposed = true;
+    if (reconnectTimer) { clearTimer(reconnectTimer); reconnectTimer = null; }
+    failPending('DISPOSED', 'Closed');
+    try { ws?.close(); } catch { /* already closed */ }
+    ws = null;
+    listeners.clear();
+  }
+
+  return {
+    open,
+    request,
+    refreshHello,
+    reconnectNow,
+    on,
+    dispose,
+    get hello() { return hello; },
+    get connected() { return !!(ws && ws.readyState === 1 && hello); },
+    get blocked() { return blocked; },
+    supports: (capability) => !!hello?.capabilities?.includes(capability),
+  };
+}

package/neural-interface/public/shared/agy/agy-commands.js

@@ -0,0 +1,120 @@
+// ═══════════════════════════════════════════
+// SynaBun — Antigravity panel: slash commands and @ mentions (no DOM)
+// ═══════════════════════════════════════════
+//
+// Two kinds of slash command meet in the composer: the agent's own (ACP
+// `available_commands_update`: Antigravity's /plan, /goal, /compact …, sent to it
+// as the text of a prompt) and the panel's (/new, /sessions, /rename …, run here).
+// An agent command wins a name both have: it is Antigravity's own behaviour, and
+// every panel action stays one click away. `@` followed by a path fragment asks
+// for a project file; the chosen one is attached to the message (ACP resource_link)
+// and its path stays in the text.
+
+/**
+ * The panel's commands. `key` is the agy-copy.js key of the description; `needs` names a capability the panel
+ * must have for it ('fork', 'logout', 'sessions'); `hint` is shown after the name.
+ */
+export const PANEL_COMMANDS = Object.freeze([
+  { name: 'new', key: 'cmdNew' },
+  { name: 'sessions', key: 'cmdSessions' },
+  { name: 'rename', key: 'cmdRename', hint: 'name' },
+  { name: 'fork', key: 'cmdFork', needs: 'fork' },
+  { name: 'retry', key: 'cmdRetry' },
+  { name: 'copy', key: 'cmdCopy' },
+  { name: 'model', key: 'cmdModel' },
+  { name: 'mode', key: 'cmdMode' },
+  { name: 'thinking', key: 'cmdThinking' },
+  { name: 'detail', key: 'cmdDetail', hint: 'compact | standard | verbose' },
+  { name: 'settings', key: 'cmdSettings' },
+  { name: 'login', key: 'cmdLogin' },
+  { name: 'logout', key: 'cmdLogout', needs: 'logout' },
+  { name: 'help', key: 'cmdHelp' },
+]);
+
+export const DETAIL_LEVELS = Object.freeze(['compact', 'standard', 'verbose']);
+
+/** "/name args" → { name, args } (name lower-cased), or null when the text is not one command. */
+export function parseSlash(text) {
+  const match = /^\/([A-Za-z0-9][\w:.-]*)(?:\s+([\s\S]*))?$/.exec(String(text ?? '').trim());
+  if (!match) return null;
+  return { name: match[1].toLowerCase(), args: (match[2] || '').trim() };
+}
+
+/**
+ * What a typed message does: { kind: 'agent' } (sent to Antigravity as typed: plain text, an agent command or an
+ * unknown one), or { kind: 'panel', name, args } for a panel command the agent does not also have.
+ */
+export function resolveSlash(text, { agentCommands = [], available = () => true } = {}) {
+  const parsed = parseSlash(text);
+  if (!parsed) return { kind: 'agent' };
+  if ((agentCommands || []).some((command) => String(command?.name || '').toLowerCase() === parsed.name)) return { kind: 'agent' };
+  const panel = PANEL_COMMANDS.find((command) => command.name === parsed.name);
+  if (!panel || (panel.needs && !available(panel.needs))) return { kind: 'agent' };
+  return { kind: 'panel', name: panel.name, args: parsed.args };
+}
+
+/**
+ * The slash menu for what the composer holds: while it is "/" plus the start of one command name, the commands
+ * whose name starts with it (panel first, then the agent's; a panel command the agent also has is left out).
+ * → { query, items: [{ name, source: 'panel' | 'agent', key?, description?, hint }] } or null.
+ */
+export function slashMenu(text, { agentCommands = [], available = () => true, max = 80 } = {}) {
+  const match = /^\/([\w:.-]*)$/.exec(String(text ?? ''));
+  if (!match) return null;
+  const query = match[1].toLowerCase();
+  const agent = (agentCommands || []).filter((command) => command && typeof command.name === 'string');
+  const agentNames = new Set(agent.map((command) => command.name.toLowerCase()));
+  const starts = (name) => name.toLowerCase().startsWith(query);
+  const items = [
+    ...PANEL_COMMANDS.filter((command) => !agentNames.has(command.name) && (!command.needs || available(command.needs)) && starts(command.name))
+      .map((command) => ({ name: command.name, source: 'panel', key: command.key, hint: command.hint || '' })),
+    ...agent.filter((command) => starts(command.name))
+      .map((command) => ({ name: command.name, source: 'agent', description: command.description || '', hint: command.hint || '' })),
+  ].slice(0, max);
+  return { query, items };
+}
+
+/** The text a chosen menu entry leaves in the composer: "/name " (a space, so its argument can follow). */
+export function slashInsert(item) {
+  return `/${item?.name || ''} `;
+}
+
+/**
+ * The @ mention the caret is in: `@` at the start or after whitespace, then a path fragment up to the caret.
+ * → { start, end, query } (start: the index of '@'), or null.
+ */
+export function mentionAt(text, caret) {
+  const value = String(text ?? '');
+  const at = Number.isInteger(caret) ? Math.max(0, Math.min(caret, value.length)) : value.length;
+  const before = value.slice(0, at);
+  const match = /(^|\s)@([^\s@]{0,200})$/.exec(before);
+  if (!match) return null;
+  const start = at - match[2].length - 1;
+  return { start, end: at, query: match[2] };
+}
+
+/** The composer after a file was picked for a mention: "@relative/path " in place of "@query". → { text, caret }. */
+export function applyMention(text, mention, relativePath) {
+  const value = String(text ?? '');
+  const insert = `@${relativePath} `;
+  const next = value.slice(0, mention.start) + insert + value.slice(mention.end).replace(/^\s+/, '');
+  return { text: next, caret: mention.start + insert.length };
+}
+
+/** A project-relative path joined to the project folder (either separator; never leaves the folder). */
+export function joinProjectPath(project, relativePath) {
+  const root = String(project || '').replace(/[\\/]+$/, '');
+  const rel = String(relativePath || '').replace(/^[\\/]+/, '');
+  if (!root || !rel || rel.split(/[\\/]/).some((part) => part === '..')) return '';
+  const sep = root.includes('\\') && !root.includes('/') ? '\\' : '/';
+  return `${root}${sep}${rel.replace(/[\\/]/g, sep)}`;
+}
+
+/** A path shown relative to the project when it is inside it, else as it is. */
+export function relativeToProject(project, path) {
+  const root = String(project || '').replace(/[\\/]+$/, '');
+  const value = String(path || '');
+  if (root && (value === root)) return '.';
+  if (root && (value.startsWith(`${root}/`) || value.startsWith(`${root}\\`))) return value.slice(root.length + 1);
+  return value;
+}