ucode-agent 1.60.2 → 1.61.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.60.2",
+  "version": "1.61.1",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on Google Gemini models.",
   "type": "module",
   "main": "ucode.js",

package/src/core/doctor.js

@@ -12,7 +12,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { theme, dim, blue } from '../ui/theme.js';
 import { VERSION } from './version.js';
-import { DEFAULT_MODEL, ENV_FILE, BASE_URL, providerKey } from './provider.js';
+import { ENV_FILE, BASE_URL, providerKey } from './provider.js';
 import { newer } from './updater.js';
 
 const DEADLINE = 6000;
@@ -27,22 +27,11 @@ async function checkKey() {
   const key = providerKey();
   if (!key) return { ok: false, name: 'API key', detail: 'not set', fix: `Add GEMINI_API_KEY=... to ${ENV_FILE} (free at aistudio.google.com/apikey)` };
   try {
-    const r = await fetch(`${BASE_URL}/chat/completions`, {
-      method: 'POST',
-      headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ model: DEFAULT_MODEL, messages: [{ role: 'user', content: 'ok' }], max_tokens: 1 }),
-      signal: timed(),
-    });
-    if (r.status === 401 || r.status === 403) return { ok: false, name: 'API key', detail: 'rejected', fix: 'Check the key for typos, or make a new one' };
-    const body = await r.json().catch(() => ({}));
-    const meta = body?.error?.metadata?.headers ?? {};
-    const left = r.headers.get('x-ratelimit-remaining') ?? meta['X-RateLimit-Remaining'];
-    const reset = Number(r.headers.get('x-ratelimit-reset') ?? meta['X-RateLimit-Reset']);
-    if (r.status === 429 && /per[- ]day|daily/i.test(`${body?.error?.message} ${body?.error?.metadata?.limit_source}`)) {
-      const at = Number.isFinite(reset) ? new Date(reset).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : 'tomorrow';
-      return { ok: false, name: 'Requests today', detail: 'daily free limit used up', fix: `It resets at ${at}; adding credit raises the limit` };
-    }
-    return { ok: true, name: 'API key', detail: left != null ? `works · ${left} free requests left today` : 'works' };
+    // Listing models checks the key in under a second; a chat request can queue for half a minute.
+    const r = await fetch(`${BASE_URL}/models`, { headers: { Authorization: `Bearer ${key}` }, signal: timed() });
+    if ([400, 401, 403].includes(r.status)) return { ok: false, name: 'API key', detail: 'rejected', fix: 'Check the key for typos, or make a new one' };
+    if (!r.ok) return { ok: false, name: 'API key', detail: `could not check (HTTP ${r.status})`, fix: 'Try again in a minute' };
+    return { ok: true, name: 'API key', detail: 'works' };
   } catch (err) {
     return { ok: false, name: 'API key', detail: `could not check (${err.name === 'TimeoutError' ? 'no answer' : err.message})`, fix: 'Check your internet connection' };
   }

package/src/core/loop.js

@@ -14,7 +14,7 @@
 import path from 'node:path';
 import os from 'node:os';
 import { pathToFileURL } from 'node:url';
-import { appendFileSync, existsSync } from 'node:fs';
+import { appendFileSync, existsSync, statSync } from 'node:fs';
 import { readFile, readdir, access, mkdir } from 'node:fs/promises';
 import { testRunnerFor, relatedCommand, summariseFailures } from './tests.js';
 import { LogWatch } from './livelog.js';
@@ -1773,23 +1773,57 @@ export class Agent {
     }
   }
 
-  /** /deploy [folder] — the same tool the model calls, run directly. */
+  /**
+   * /deploy puts an app online — only when the user types it.
+   *
+   *   /deploy          the app made most recently (this session, else the newest folder here)
+   *   /deploy <folder> that one
+   *   /deploy all      every app in this folder, one link each
+   */
   async cmdDeploy(arg) {
-    const folder = (arg ?? '').trim() || '.';
-    this.ui.toolCall(`Deploying ${folder}`);
-    this.ui.startSpinner('getting ready to deploy');
-    try {
-      const out = await deploy({ folder }, { onOutput: (lines) => this.ui.updateSpinner(lines.at(-1)) });
-      this.ui.stopSpinner();
-      this.ui.toolResult(out.summary);
-      this.ui.write(out.content.split('\n').map((l) => `  ${l}`).join('\n'));
-    } catch (err) {
-      this.ui.stopSpinner();
-      if (err instanceof ToolFailure) this.ui.error(err);
-      else throw err;
+    const wanted = (arg ?? '').trim();
+    const apps = await this.appFolders();
+    let folders;
+    if (wanted === 'all') folders = apps;
+    else if (wanted) folders = [wanted];
+    else {
+      const made = this.apps?.at(-1);
+      folders = [made ? path.relative(this.cwd, made).split(path.sep).join('/') || '.' : (apps[0] ?? '.')];
+    }
+    if (!folders.length) {
+      this.ui.note('no apps here to deploy — build one first, or /deploy <folder>');
+      return;
+    }
+    for (const folder of folders) {
+      this.ui.toolCall(`Deploying ${folder}`);
+      this.ui.startSpinner('getting ready to deploy');
+      try {
+        const out = await deploy({ folder }, { onOutput: (lines) => this.ui.updateSpinner(lines.at(-1)) });
+        this.ui.stopSpinner();
+        this.ui.toolResult(out.summary);
+        this.ui.write(out.content.split('\n').map((l) => `  ${l}`).join('\n'));
+      } catch (err) {
+        this.ui.stopSpinner();
+        if (err instanceof ToolFailure) this.ui.error(err);
+        else throw err;
+      }
     }
   }
 
+  /** App folders here, newest first: the folder itself if it is one, else its subfolders with a page or package.json. */
+  async appFolders() {
+    if (await exists(path.join(this.cwd, 'index.html'))) return ['.'];
+    const found = [];
+    for (const entry of await readdir(this.cwd, { withFileTypes: true }).catch(() => [])) {
+      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      const dir = path.join(this.cwd, entry.name);
+      if ((await exists(path.join(dir, 'index.html'))) || (await exists(path.join(dir, 'package.json')))) {
+        found.push({ name: entry.name, at: statSync(dir).mtimeMs });
+      }
+    }
+    return found.sort((a, b) => b.at - a.at).map((f) => f.name);
+  }
+
   reportResult(call, out) {
     // A build or type check that just passed already verified everything
     // changed so far; the automatic check at the end would only repeat it.
@@ -1912,6 +1946,26 @@ export class Agent {
       .map((f) => ({ abs: path.resolve(this.cwd, f.path), size: f.content.length, path: f.path }));
   }
 
+  /**
+   * A model that has just made todo-app/ sometimes writes app.js beside it
+   * instead of in it: the page never gets its script, and the hand-over, which
+   * watches the app folder, never fires. A bare name the app already has, and
+   * this folder does not, goes into the app.
+   */
+  intoApp(call) {
+    const app = this.apps?.at(-1);
+    if (!app) return;
+    const fix = (p) => {
+      if (typeof p !== 'string' || path.isAbsolute(p) || existsSync(path.resolve(this.cwd, p))) return p;
+      const inside = path.join(app, p);
+      if (path.relative(app, inside).startsWith('..') || !existsSync(inside)) return p;
+      return path.relative(this.cwd, inside).split(path.sep).join('/');
+    };
+    const a = call.args ?? {};
+    if (call.name === 'write_file') a.path = fix(a.path);
+    else if (call.name === 'batch_write') a.files = normaliseFiles(a.files).map((f) => (f && typeof f === 'object' ? { ...f, path: fix(f.path) } : f));
+  }
+
   async dispatch(call, offered = this.offering) {
     // The model emitted arguments that were not valid JSON. Hand the parser's
     // own complaint straight back so it can correct itself next step.
@@ -2019,6 +2073,8 @@ export class Agent {
       }
     }
 
+    if (call.name === 'write_file' || call.name === 'batch_write') this.intoApp(call);
+
     if (call.name === 'load_skill') return this.loadSkill(call.args?.name);
     if (call.name === 'update_plan') return this.updatePlan(call.args?.items);
     if (call.name === 'delegate') return this.delegate(call.args?.tasks);
@@ -2525,7 +2581,7 @@ export class Agent {
     }
 
     const content = String(out?.content ?? '');
-    if (/Console errors|Failed requests|NOTHING HAPPENS|does not parse/i.test(content)) {
+    if (/Console errors|Failed requests|NOTHING HAPPENS|ADDING DOES NOT WORK|works until you refresh|does not parse/i.test(content)) {
       this.handOverPending = true;
       this.ui.runStat?.('needs a fix');
       return { problems: `I opened the app and looked at it:\n\n${content}` };

package/src/tools/browser.js

@@ -218,7 +218,90 @@ const moved = (a, b) => a.nodes !== b.nodes || a.html !== b.html || a.stored !==
  * not exercised and not judged. Returning null there is the difference between
  * a check and a false accusation.
  */
+/**
+ * Add something, the way a person would, and see it land on the page.
+ *
+ * Typing into "the first field" found a todo app's search box: the search
+ * filtered the empty list, the page changed, and an app whose Add did nothing
+ * at all was reported as working. So for anything shaped like a list — an
+ * input that is not a search, or a New / Add button — the probe text is added
+ * and must then appear in the page's visible text. Returns null for pages with
+ * nothing to add to, so a calculator or a weather lookup is judged as before.
+ */
+const NOT_ADD = /search|filter|find|sort|query/i;
+const LIST_HINT = /task|todo|to-do|item|note|add|new|entry|expense|habit|title|what needs|remind/i;
+const ADD_BUTTON = /^\s*(?:\+|add|new|create|save|submit|post|done)\b|\b(?:add|create|save)\s/i;
+
+async function tryAdd(page) {
+  const shows = () => page.evaluate((t) => document.body.innerText.includes(t), PROBE_TEXT).catch(() => false);
+  const settle = () => page.waitForTimeout(400);
+  const hintOf = (el) => el.evaluate((e) => [e.placeholder, e.getAttribute('aria-label'), e.name, e.id]
+    .filter(Boolean).join(' ')).catch(() => '');
+  const addField = async () => {
+    const inputs = page.locator('input[type="text"], input:not([type]), textarea');
+    const n = Math.min(await inputs.count().catch(() => 0), 10);
+    for (let i = 0; i < n; i++) {
+      const el = inputs.nth(i);
+      if (!(await el.isVisible().catch(() => false))) continue;
+      const hint = await hintOf(el);
+      if (!NOT_ADD.test(hint)) return { el, hint };
+    }
+    return null;
+  };
+  const addButton = async (words = ADD_BUTTON) => {
+    const buttons = page.locator('button:not([disabled]), input[type="submit"], [role="button"]');
+    const n = Math.min(await buttons.count().catch(() => 0), 30);
+    for (let i = 0; i < n; i++) {
+      const b = buttons.nth(i);
+      const label = ((await b.innerText().catch(() => '')) || (await b.getAttribute('value').catch(() => '')) ||
+        (await b.getAttribute('aria-label').catch(() => '')) || '').trim().replace(/\s+/g, ' ');
+      if (words.test(label) && (await b.isVisible().catch(() => false))) return { b, label: label.slice(0, 24) };
+    }
+    return null;
+  };
+
+  const tried = [];
+  let field = await addField();
+  let listApp = Boolean(field && LIST_HINT.test(field.hint));
+  if (!field) {
+    // No field yet: the form may be behind a "New task" / "+" button.
+    // Words only: a calculator's "+" opens nothing.
+    const opener = await addButton(/\b(?:add|new|create)\b/i);
+    if (!opener) return null;
+    listApp = true;
+    await opener.b.click({ timeout: 2_000 }).catch(() => {});
+    await settle();
+    tried.push(`clicked "${opener.label}"`);
+    field = await addField();
+    // No field appeared: that button was not a form opener ("Add one" on a
+    // counter), so this is not a list app, and the normal check judges it.
+    if (!field) return { tried, added: false, listApp: false };
+  }
+  const ok = await field.el.fill(PROBE_TEXT, { timeout: 2_000 }).then(() => true).catch(() => false);
+  if (!ok) return tried.length ? { tried, added: false, listApp } : null;
+  await field.el.press('Enter', { timeout: 2_000 }).catch(() => {});
+  await settle();
+  tried.push(`typed "${PROBE_TEXT}" into ${field.hint ? `"${field.hint.slice(0, 30)}"` : 'the field'} and pressed Enter`);
+  if (await shows()) return { tried, added: true, listApp };
+
+  const button = await addButton();
+  if (button) {
+    listApp = true;
+    await button.b.click({ timeout: 2_000 }).catch(() => {});
+    await settle();
+    tried.push(`clicked "${button.label}"`);
+    if (await shows()) return { tried, added: true, listApp };
+  }
+  return { tried, added: false, listApp };
+}
+
 async function useTheApp(page) {
+  // A list app is judged by whether adding works, not by whether anything moved.
+  const add = await tryAdd(page).catch(() => null);
+  if (add?.added) return { tried: add.tried, worked: true };
+  if (add?.listApp) return { tried: add.tried, worked: false, addFailed: true };
+  if (add?.tried.length) await page.reload({ waitUntil: 'load', timeout: 20_000 }).catch(() => {});
+
   const snapshot = () => page.evaluate(() => ({
     nodes: document.body.querySelectorAll('*').length,
     text: document.body.innerText.replace(/\s+/g, ' ').trim().length,
@@ -487,7 +570,15 @@ export async function lookAtApp({ url, paths = ['/'], review: withReview = true
       if (f.smallText) lines.push(`- ${at}: ${f.smallText} text element(s) under 12px.`);
     }
 
-    if (used && !used.worked) {
+    if (used?.addFailed) {
+      lines.push(
+        `- ADDING DOES NOT WORK. I ${used.tried.join(', then ')} — and "${PROBE_TEXT}" never`,
+        '  appeared on the page. Adding an item is the whole app. Wire the add input and its',
+        '  button to code that pushes the item, saves it and re-renders the list, and make',
+        '  sure no error stops that code before it runs.',
+      );
+      problems++;
+    } else if (used && !used.worked) {
       lines.push(
         `- NOTHING HAPPENS WHEN YOU USE IT. I ${used.tried.join(', then ')} — and the page`,
         '  gained no elements, changed no text and stored nothing. The markup and the styling',

package/src/tools/deploy.js

@@ -231,7 +231,7 @@ export async function deploy({ folder = '.', name } = {}, { onOutput } = {}) {
   if (staticSite) {
     const config = path.join(dir, 'vercel.json');
     if (!existsSync(config)) {
-      await fs.writeFile(config, JSON.stringify({ buildCommand: null, outputDirectory: '.' }, null, 2) + '\n');
+      await fs.writeFile(config, JSON.stringify({ buildCommand: null, outputDirectory: '.' }, null, 2) + '\n');
     }
     const sending = (await fs.readdir(dir, { withFileTypes: true }))
       .filter((e) => e.isFile() && !e.name.startsWith('.') && e.name !== 'vercel.json')
@@ -249,6 +249,12 @@ export async function deploy({ folder = '.', name } = {}, { onOutput } = {}) {
     });
   }
 
+  // Vercel turns on "Vercel Authentication" for new projects, which puts every
+  // .vercel.app address behind a Vercel login: the link worked for the account
+  // owner and asked everyone else to sign in. /deploy is asking for a public
+  // site, so the project is made public.
+  await api(`/v9/projects/${link.projectId}`, { method: 'PATCH', body: { ssoProtection: null } }).catch(() => {});
+
   say('Uploading and building on Vercel');
   const started = Date.now();
   const { code, output } = await new Promise((resolve) => {
@@ -284,9 +290,18 @@ export async function deploy({ folder = '.', name } = {}, { onOutput } = {}) {
     });
   }
 
-  const live = `https://${link.projectName}.vercel.app`;
-  const ok = await fetchImpl(live, { signal: AbortSignal.timeout(15_000) }).then((r) => r.status < 400).catch(() => false);
-  const url = ok ? live : (output.match(/https:\/\/[a-z0-9.-]+\.vercel\.app/g) ?? [live]).at(-1);
+  // The address people can open is the project's production alias, which is
+  // not always <name>.vercel.app: a taken name gets a suffix ("-eta"). Guessing
+  // it handed out a 404, and falling back to the deployment's own URL handed
+  // out one that sits behind a Vercel login. Ask Vercel for the real one.
+  const project = await api(`/v9/projects/${link.projectId}`).catch(() => ({ json: {} }));
+  const aliases = (project.json?.targets?.production?.alias ?? []).slice().sort((a, b) => a.length - b.length);
+  const opens = (u) => fetchImpl(u, { redirect: 'manual', signal: AbortSignal.timeout(15_000) })
+    .then((r) => r.status < 300).catch(() => false);
+  let url = `https://${link.projectName}.vercel.app`;
+  for (const alias of aliases) {
+    if (await opens(`https://${alias}`)) { url = `https://${alias}`; break; }
+  }
   return result(
     [
       `Live at ${url}`,