ucode-agent 1.63.0 → 1.65.0

package/src/tools/shared.js

@@ -10,6 +10,7 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { ToolFailure, Declined } from '../core/failure.js';
+import { isAllowed, commandKey } from '../core/settings.js';
 
 /**
  * How much of a result the model may see.
@@ -63,7 +64,25 @@ export function setConfirm(fn) {
   asker = fn;
 }
 
-export async function confirm(action, detail, risk = 'write') {
+/**
+ * What may run without asking. `askCommands` is the "commands": "ask" setting;
+ * `allow` is the always-allow list; `onAlways` saves a new entry to it.
+ */
+let policy = { askCommands: false, allow: [], onAlways: null };
+
+export function setPolicy(next) {
+  policy = { ...policy, ...next };
+}
+
+/** Is this command, or "mcp:tool", on the always-allow list? */
+export const allowedNow = (subject) => isAllowed(policy.allow, subject);
+
+/**
+ * Ask before acting. `always` names what an "always" answer allows from then
+ * on: a command's first words, or "mcp:tool". Callers check allowedNow()
+ * against the whole command first — the entry is only what gets saved.
+ */
+export async function confirm(action, detail, risk = 'write', always = null) {
   if (!asker) {
     throw new ToolFailure({
       kind: 'cannot_ask',
@@ -72,7 +91,19 @@ export async function confirm(action, detail, risk = 'write') {
       fix: 'Run ucode in a terminal so it can prompt before acting.',
     });
   }
-  if (!(await asker({ action, detail, risk }))) throw new Declined(action);
+  const answer = await asker({ action, detail, risk, always });
+  if (answer === 'always' && always) {
+    policy = { ...policy, allow: [...policy.allow, always] };
+    await Promise.resolve(policy.onAlways?.(always)).catch(() => {});
+    return;
+  }
+  if (!answer) throw new Declined(action);
+}
+
+/** A command about to run, put to the user first when they asked for that. */
+export async function approveCommand(command, where) {
+  if (!policy.askCommands || allowedNow(command)) return;
+  await confirm(`run ${String(command).trim().slice(0, 160)}`, `in ${where}`, 'command', commandKey(command));
 }
 
 // ---------------------------------------------------------------------------

package/src/tools/shell.js

@@ -14,7 +14,7 @@ import { openSync, closeSync, readFileSync, mkdirSync, statSync } from 'node:fs'
 import os from 'node:os';
 import path from 'node:path';
 import { ToolFailure } from '../core/failure.js';
-import { resolveIn, guard, confirm, result, getRoot, MAX_OUTPUT } from './shared.js';
+import { resolveIn, guard, confirm, approveCommand, result, getRoot, MAX_OUTPUT } from './shared.js';
 
 const DEFAULT_TIMEOUT = 120_000;
 const MAX_TIMEOUT = 600_000;
@@ -713,6 +713,9 @@ export async function runCommand({ command, cwd, timeout_ms, background }, { onO
     : { abs: getRoot(), inside: true, show: '.' };
   await guard(workdir, `run a command in ${workdir.abs}`);
 
+  // "commands": "ask" in settings: every command is put to the user first.
+  await approveCommand(command, workdir.show);
+
   const env = childEnv();
   const server = startsServer(command);
 

package/src/ui/activity.js

@@ -12,7 +12,7 @@
  */
 
 import chalk, { Chalk } from 'chalk';
-import { dim, sky, theme, clip, SPINNER, bannerRGB, bannerPaint } from './theme.js';
+import { dim, sky, theme, clip, SPINNER, bannerRGB, bannerPaint, look, hexRGB } from './theme.js';
 
 /** One painter per colour level, so a test can ask for truecolour on a pipe. */
 const painters = new Map();
@@ -289,7 +289,7 @@ export function spinnerGlyph(frame, t, { level = chalk.level } = {}) {
   const glyph = SPINNER[((frame % SPINNER.length) + SPINNER.length) % SPINNER.length];
   if (level < 2) return theme.blue(glyph);
   const k = (Math.sin((Math.max(0, t) / 1000) * Math.PI * 2) + 1) / 2;
-  const [r, g, b] = mix([0x2f, 0x6f, 0xe0], [0x9f, 0xc6, 0xff], k);
+  const [r, g, b] = mix(hexRGB(look.deep), hexRGB(look.light), k);
   return painter(level).rgb(r, g, b)(glyph);
 }
 

package/src/ui/plain.js

@@ -14,7 +14,7 @@ import chalk from 'chalk';
 import {
   theme, blue, sky, dim, boxTop, boxBottom, boxRow,
   BANNER, BANNER_WIDTH, SPINNER, clip, shortenPath, asLabel, padVis, visLen, planLine, bannerPaint, modeChip, narrationMark, groupKind,
-  tidyReply, trimAnswer,
+  tidyReply, trimAnswer, look,
 } from './theme.js';
 import { formatDuration, doneLine } from './activity.js';
 import { renderer, render } from './markdown.js';
@@ -24,6 +24,9 @@ const COMMANDS = [
   '/new', '/remember', '/skills', '/clear', '/search', '/copy', '/exit',
 ];
 
+/** The tag on an approval prompt. */
+export const badge = (risk) => ({ command: ' shell ', mcp: ' tool ', trust: ' project ' })[risk] ?? ' outside project ';
+
 export class Plain {
   constructor({ cwd, input = process.stdin, output = process.stdout } = {}) {
     this.cwd = cwd;
@@ -98,7 +101,7 @@ export class Plain {
       ['keys', '/help'],
       ['', ''],
       ['', ''],
-      ['', 'made with ❤ by om dixit'],
+      ['', look.byline],
     ];
 
     // There is no input box to hang the status off here, so it goes on the
@@ -293,18 +296,18 @@ export class Plain {
     return this.promptWith(`${blue('› ')}`);
   }
 
-  async confirm({ action, detail, risk }) {
+  async confirm({ action, detail, risk, always }) {
     this.stopSpinner();
-    const badge = risk === 'command' ? ' shell ' : ' outside project ';
-    this.output.write(`\n${chalk.inverse(theme.warn(badge))} ${chalk.white(action)}\n`);
+    this.output.write(`\n${chalk.inverse(theme.warn(badge(risk)))} ${chalk.white(action)}\n`);
     for (const line of String(detail ?? '').split('\n')) {
       if (line) this.output.write(dim(`  ${line}\n`));
     }
 
-    const answer = await this.promptWith(`${blue('  go ahead? ')}${dim('[y/N] ')}`);
+    const answer = await this.promptWith(`${blue('  go ahead? ')}${dim(always ? `[y/N, a = always allow ${always}] ` : '[y/N] ')}`);
     // End of input is a no: never run something nobody approved.
-    const yes = /^(y|yes)$/i.test(String(answer ?? '').trim());
-    this.output.write(dim(yes ? '  approved\n\n' : '  declined\n\n'));
+    const said = String(answer ?? '').trim();
+    const yes = always && /^(a|always)$/i.test(said) ? 'always' : /^(y|yes)$/i.test(said);
+    this.output.write(dim(yes === 'always' ? `  approved — ${always} is always allowed here now\n\n` : yes ? '  approved\n\n' : '  declined\n\n'));
     return yes;
   }
 

package/src/ui/screen.js

@@ -37,13 +37,14 @@ import { homedir } from 'node:os';
 import path from 'node:path';
 import chalk from 'chalk';
 import {
-  theme, blue, sky, deep, dim, edge, ADDED, REMOVED, BANNER, BANNER_WIDTH, SPINNER,
+  theme, blue, sky, deep, dim, edge, ADDED, REMOVED, BANNER, BANNER_WIDTH, SPINNER, look,
   boxTop, boxBottom, boxRow, visLen, padVis, clip, wrapAnsi,
   shortenPath, asLabel, ensureColour, planLine, bare, narration, narrationMark, groupKind, groupLabel, groupTarget, runLine, planRows, tidyReply, trimAnswer,
   bannerPaint, RAIL, modeChip, ADD_CHIP, micChip, asNarrationLine } from './theme.js';
 import { FRAME_MS, spinnerGlyph, formatDuration, doneLine, workingLine, bannerSweep, SWEEP_MS } from './activity.js';
 import { gitBranch } from '../core/git.js';
 import { renderer, render } from './markdown.js';
+import { badge } from './plain.js';
 import { VERSION } from '../core/version.js';
 
 /**
@@ -818,7 +819,7 @@ export class Screen {
     ].filter(Boolean).slice(0, BANNER.length - 1);
 
     while (facts.length < BANNER.length - 1) facts.push(['', '']);
-    facts.push(['', 'made with ❤ by om dixit']);
+    facts.push(['', look.byline]);
 
     const rows = BANNER.map((art, i) => {
       const [label, text] = facts[i] ?? ['', ''];
@@ -1203,22 +1204,23 @@ export class Screen {
   }
 
   /** y/n, answered on the input line. */
-  confirm({ action, detail, risk }) {
+  confirm({ action, detail, risk, always }) {
     this.push('');
-    this.push(`${chalk.inverse(theme.warn(risk === 'command' ? ' shell ' : ' outside project '))} ${chalk.white(action)}`);
+    this.push(`${chalk.inverse(theme.warn(badge(risk)))} ${chalk.white(action)}`);
     for (const line of String(detail ?? '').split('\n')) {
       if (line) this.push(dim(`  ${line}`));
     }
 
-    this.pendingPrompt = 'go ahead? [y/N]';
+    this.pendingPrompt = always ? `go ahead? [y/N, a = always allow ${always}]` : 'go ahead? [y/N]';
     this.scroll = 0; // the question has to be on screen to be answered
     this.render();
 
     return this.nextLine().then((answer) => {
       this.pendingPrompt = null;
       // End of input counts as no. Never run something nobody approved.
-      const yes = /^(y|yes)$/i.test(String(answer ?? '').trim());
-      this.push(dim(yes ? '  approved' : '  declined'));
+      const said = String(answer ?? '').trim();
+      const yes = always && /^(a|always)$/i.test(said) ? 'always' : /^(y|yes)$/i.test(said);
+      this.push(dim(yes === 'always' ? `  approved — ${always} is always allowed here now` : yes ? '  approved' : '  declined'));
       this.push('');
       return yes;
     });

package/src/ui/theme.js

@@ -9,12 +9,17 @@
  */
 
 import chalk from 'chalk';
+import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 
 // One hue, three weights. Anything that needs a fourth is asking for emphasis
-// it has not earned.
-export const blue = chalk.hex('#4d8dff');   // structure: borders, the caret, the wordmark
-export const sky = chalk.hex('#8fbcff');    // secondary: labels that still matter
-export const deep = chalk.hex('#2f6fe0');   // pressed, quiet, behind
+// it has not earned. The hue is the user's to change ("make ucode orange"):
+// these are `let`, so every module that imported them sees a new look the
+// moment applyLook() runs - see the "Your look" section below.
+export let blue = chalk.hex('#4d8dff');   // structure: borders, the caret, the wordmark
+export let sky = chalk.hex('#8fbcff');    // secondary: labels that still matter
+export let deep = chalk.hex('#2f6fe0');   // pressed, quiet, behind
 export const dim = chalk.dim;
 
 /**
@@ -25,7 +30,7 @@ export const dim = chalk.dim;
  * terminal fonts visibly thicker, which is enough to separate "where you type"
  * from "what you are reading" without a second colour.
  */
-export const edge = chalk.hex('#4d8dff').bold;
+export let edge = chalk.hex('#4d8dff').bold;
 
 /**
  * The colour level to use for a stream, or null to leave chalk's guess alone.
@@ -87,8 +92,8 @@ export const BANNER_WIDTH = Math.max(...BANNER.map((r) => r.length));
  * the page. chalk downshifts the hex to whatever the terminal actually has, so
  * on a 16-colour terminal this is flat blue again rather than nothing.
  */
-const GRADIENT_TOP = [0x8f, 0xbc, 0xff];      // sky, at the crown
-const GRADIENT_BOTTOM = [0x2f, 0x6f, 0xe0];   // deep, in the shadow
+let GRADIENT_TOP = [0x8f, 0xbc, 0xff];      // sky, at the crown
+let GRADIENT_BOTTOM = [0x2f, 0x6f, 0xe0];   // deep, in the shadow
 
 export function bannerRGB(row, rows = BANNER.length) {
   const t = rows > 1 ? Math.min(1, Math.max(0, row / (rows - 1))) : 0;
@@ -121,14 +126,14 @@ export const RAIL = '▌';
  * once: it is the width of the word, the way a diff's tint is the width of the
  * line it marks.
  */
-export const BUILD_CHIP = chalk.bgHex('#4d8dff').hex('#0b1220').bold;
-export const PLAN_CHIP = chalk.bgHex('#24344f').hex('#8fbcff').bold;
+export let BUILD_CHIP = chalk.bgHex('#4d8dff').hex('#0b1220').bold;
+export let PLAN_CHIP = chalk.bgHex('#24344f').hex('#8fbcff').bold;
 
 export const modeChip = (mode) =>
   mode === 'plan' ? PLAN_CHIP(' PLAN ') : BUILD_CHIP(' BUILD ');
 
 /** The "+ file" button beside the mode chip, in the quieter of the two chip styles. */
-export const ADD_CHIP = PLAN_CHIP(' + file ');
+export let ADD_CHIP = PLAN_CHIP(' + file ');
 
 /** The mic button beside it: quiet when idle, red while it is listening. */
 const LISTEN_CHIP = chalk.bgHex('#e5484d').hex('#ffffff').bold;
@@ -138,7 +143,7 @@ export const micChip = (state) =>
       : PLAN_CHIP(' mic ');
 
 /** The spinner. Braille dots, because they animate in place without jitter. */
-export const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export let SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
 // ---------------------------------------------------------------------------
 // Boxes
@@ -794,8 +799,30 @@ const CAVEAT = /\b(?:however|failed|couldn't|could not|cannot|can't|didn't|did n
 const ACTIONABLE = /\b(?:open|run|serve|visit|try|start|npm|npx|node|pnpm|yarn)\b|https?:\/\/|\.(?:html?|css|jsx?|tsx?|md|json|py|rs|go)\b/i;
 const BULLET = /^\s*(?:[-*•>]|\d+[.)]|[✓✔✅☑])\s+/;
 
+/**
+ * Words that say nothing about this app, because they are said about every
+ * app: "a sleek, modern and intuitive interface for a seamless experience".
+ */
+export const STOCK = /\b(?:seamless(?:ly)?|sleek|modern and clean|clean and modern|robust|intuitive|user-friendly|cutting-edge|state-of-the-art|elevate[sd]?|effortless(?:ly)?|stunning|delightful|vibrant|happy coding|feel free to|i hope (?:this|you)|let me know if)\b/i;
+
+/**
+ * The closing message without its stock sentences. A sentence goes only when
+ * it is pure filler: one that says how to try the app, or admits something is
+ * unfinished, stays whatever words it uses. Never returns nothing.
+ */
+export function withoutStock(text) {
+  const lines = String(text ?? '').replace(/\r/g, '').split('\n');
+  const out = [];
+  for (const line of lines) {
+    if (!STOCK.test(line)) { out.push(line); continue; }
+    const kept = line.split(/(?<=[.!?])\s+/).filter((s) => !STOCK.test(s) || ACTIONABLE.test(s) || CAVEAT.test(s));
+    if (kept.length) out.push(kept.join(' '));
+  }
+  return out.join('\n').trim() || lines.join('\n').trim();
+}
+
 export function trimAnswer(text, max = ANSWER_LINES) {
-  const all = String(text ?? '').replace(/\r/g, '').split('\n');
+  const all = withoutStock(text).split('\n');
 
   let start = 0;
   while (start < all.length && (!all[start].trim() || RESTATED.test(all[start].trim()))) start++;
@@ -848,3 +875,127 @@ function withinRoom(text, room = ANSWER_ROOM) {
   }
   return (out.trim() || text.slice(0, room)).trim();
 }
+
+// ---------------------------------------------------------------------------
+// Your look
+// ---------------------------------------------------------------------------
+
+/**
+ * ucode's look is the user's to change, by asking: "make yourself orange",
+ * "a calmer spinner", "put my name under the logo". It is a small file of
+ * choices rather than an edit to this one, so it survives every update and can
+ * never break ucode - a value that does not parse is simply ignored.
+ *
+ *   { "accent": "#ff8c2b", "light": "#ffb454", "deep": "#c2410c",
+ *     "spinner": "dots", "byline": "made by me" }
+ *
+ * Only accent is needed; light and deep are worked out from it.
+ */
+export const LOOK_FILE = process.env.UCODE_LOOK_FILE || path.join(os.homedir(), '.ucode', 'theme.json');
+
+export const SPINNERS = {
+  dots: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+  line: ['-', '\\', '|', '/'],
+  arc: ['◜', '◠', '◝', '◞', '◡', '◟'],
+  circle: ['◐', '◓', '◑', '◒'],
+  square: ['◰', '◳', '◲', '◱'],
+  bounce: ['⠁', '⠂', '⠄', '⠂'],
+  pulse: ['·', '•', '●', '•'],
+  star: ['✶', '✸', '✹', '✺', '✹', '✸'],
+};
+
+export const DEFAULT_LOOK = Object.freeze({
+  accent: '#4d8dff', light: '#8fbcff', deep: '#2f6fe0', spinner: 'dots', byline: 'made with ❤ by om dixit',
+});
+
+const NAMED = {
+  red: '#ef4444', orange: '#f97316', amber: '#f59e0b', gold: '#eab308', yellow: '#facc15', lime: '#84cc16',
+  green: '#22c55e', emerald: '#10b981', teal: '#14b8a6', cyan: '#06b6d4', sky: '#0ea5e9', blue: '#4d8dff',
+  indigo: '#6366f1', violet: '#8b5cf6', purple: '#a855f7', magenta: '#d946ef', pink: '#ec4899', rose: '#f43f5e',
+  white: '#f5f5f5', grey: '#9ca3af', gray: '#9ca3af', silver: '#c0c0c0', black: '#111111', brown: '#a16207',
+  coral: '#ff7f50', salmon: '#fa8072', navy: '#1e3a8a', maroon: '#9f1239', olive: '#65a30d', mint: '#6ee7b7',
+  lavender: '#c4b5fd', peach: '#fdba74', crimson: '#dc143c', turquoise: '#40e0d0',
+};
+
+/** '#abc', '#aabbcc', 'rgb(1,2,3)' or a colour name, as '#rrggbb' - or null. */
+export function normaliseColour(value) {
+  const v = String(value ?? '').trim().toLowerCase();
+  if (NAMED[v]) return NAMED[v];
+  const short = /^#?([0-9a-f])([0-9a-f])([0-9a-f])$/.exec(v);
+  if (short) return `#${short[1]}${short[1]}${short[2]}${short[2]}${short[3]}${short[3]}`;
+  const long = /^#?([0-9a-f]{6})$/.exec(v);
+  if (long) return `#${long[1]}`;
+  const rgb = /^rgb\(\s*(\d{1,3})[\s,]+(\d{1,3})[\s,]+(\d{1,3})\s*\)$/.exec(v);
+  if (rgb && rgb.slice(1).every((n) => Number(n) <= 255)) {
+    return `#${rgb.slice(1).map((n) => Number(n).toString(16).padStart(2, '0')).join('')}`;
+  }
+  return null;
+}
+
+export const hexRGB = (hex) => [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16));
+const rgbHex = (rgb) => `#${rgb.map((v) => Math.round(v).toString(16).padStart(2, '0')).join('')}`;
+
+/** Part of the way from one colour to another: t = 0 is a, 1 is b. */
+export const mixHex = (a, b, t) => rgbHex(hexRGB(a).map((v, i) => v + (hexRGB(b)[i] - v) * t));
+
+/** The look in the file, or nothing. Never throws. */
+export function readLook(file = LOOK_FILE) {
+  try {
+    const data = JSON.parse(readFileSync(file, 'utf8'));
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+/** The current look, filled out: what applyLook settled on. */
+export let look = { ...DEFAULT_LOOK };
+
+/** Put a look on screen. Missing or broken values fall back to the default. */
+export function applyLook(wanted = {}) {
+  const accent = normaliseColour(wanted.accent) ?? DEFAULT_LOOK.accent;
+  const own = accent !== DEFAULT_LOOK.accent;
+  const light = normaliseColour(wanted.light) ?? (own ? mixHex(accent, '#ffffff', 0.45) : DEFAULT_LOOK.light);
+  const deepHex = normaliseColour(wanted.deep) ?? (own ? mixHex(accent, '#000000', 0.25) : DEFAULT_LOOK.deep);
+  const spinner = SPINNERS[wanted.spinner] ? wanted.spinner : DEFAULT_LOOK.spinner;
+  const byline = typeof wanted.byline === 'string' ? wanted.byline.replace(/[\x00-\x1f]/g, '').slice(0, 40) : DEFAULT_LOOK.byline;
+
+  look = { accent, light, deep: deepHex, spinner, byline };
+  blue = chalk.hex(accent);
+  sky = chalk.hex(light);
+  deep = chalk.hex(deepHex);
+  edge = chalk.hex(accent).bold;
+  theme.blue = blue;
+  theme.sky = sky;
+  theme.deep = deep;
+  GRADIENT_TOP = hexRGB(light);
+  GRADIENT_BOTTOM = hexRGB(deepHex);
+  BUILD_CHIP = chalk.bgHex(accent).hex('#0b1220').bold;
+  PLAN_CHIP = chalk.bgHex(mixHex(deepHex, '#0b1220', 0.65)).hex(light).bold;
+  ADD_CHIP = PLAN_CHIP(' + file ');
+  SPINNER = SPINNERS[spinner];
+  return look;
+}
+
+/**
+ * Change the look and keep it: `changes` are merged into what is saved, a key
+ * set to null goes back to its default, and { reset: true } starts over.
+ */
+export function saveLook(changes = {}, { reset = false, file = LOOK_FILE } = {}) {
+  const merged = reset ? {} : { ...readLook(file) };
+  for (const [key, value] of Object.entries(changes)) {
+    if (!(key in DEFAULT_LOOK)) continue;
+    if (value === null || value === '') delete merged[key];
+    else merged[key] = value;
+  }
+  // An accent alone gets its own light and dark steps, not the old ones.
+  if ('accent' in changes && !('light' in changes)) delete merged.light;
+  if ('accent' in changes && !('deep' in changes)) delete merged.deep;
+  mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(merged, null, 2)}\n`);
+  renameSync(temp, file);
+  return applyLook(merged);
+}
+
+applyLook(readLook());

package/ucode.js

@@ -39,6 +39,9 @@ function parseArgs(argv) {
     else if (a === '--cwd' || a === '-C') args.cwd = path.resolve(argv[++i]);
     else if (a === '--help' || a === '-h') args.help = true;
     else if (a === '--version' || a === '-v') args.version = true;
+    else if (a === '--print' || a === '-p') args.print = argv[i + 1] && !argv[i + 1].startsWith('-') ? argv[++i] : '-';
+    else if (a === '--json') args.json = true;
+    else if (a === '--yes' || a === '-y') args.yes = true;
   }
 
   return args;
@@ -59,10 +62,16 @@ async function usage() {
     '    -C, --cwd <dir>    work in another directory\n' +
     '        --plan         start in plan mode: read and research, change nothing\n' +
     '        --debug        print stack traces when something breaks\n' +
+    '    -p, --print <task> do one task with no keyboard, print the answer, exit\n' +
+    '        --json         with -p: print one JSON object about the run instead\n' +
+    '    -y, --yes          with -p: say yes to anything that would be asked\n' +
     '    -v, --version      print the version\n' +
     '    -h, --help         this message\n' +
     '    doctor             check that everything ucode needs is working\n' +
-    '    login <key>        save your key for every folder on this machine\n\n' +
+    '    login <key>        save your key for every folder on this machine\n' +
+    '    mcp add <name> <command> [args...]   connect an MCP server (--url <url> for a remote one)\n' +
+    '    mcp list | mcp remove <name>\n\n' +
+    `  ${sky('Other models')}  UCODE_BASE_URL=http://localhost:11434/v1 UCODE_MODEL=<model> ucode  (Ollama, offline)\n\n` +
     `  ${sky('Models')}\n${models}\n\n` +
     `  Needs GEMINI_API_KEY in the environment or in ${ENV_FILE}\n` +
     '  Free keys: https://aistudio.google.com/apikey\n\n'
@@ -92,6 +101,33 @@ async function main() {
     return;
   }
 
+  if (process.argv[2] === 'mcp') {
+    const { mcpCommand } = await import('./src/core/mcpcli.js');
+    process.stdout.write(`${await mcpCommand(process.argv.slice(3))}\n`);
+    return;
+  }
+
+  if (args.print !== undefined) {
+    let prompt = args.print;
+    if (prompt === '-') {
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(chunk);
+      prompt = Buffer.concat(chunks).toString('utf8').trim();
+    }
+    if (!prompt) {
+      process.stderr.write('ucode -p needs a task: ucode -p "fix the failing test"\n');
+      process.exitCode = 2;
+      return;
+    }
+    const [, { setModel }] = await heavy();
+    if (args.model) setModel(args.model);
+    const { runHeadless } = await import('./src/core/headless.js');
+    const code = await runHeadless({ cwd: args.cwd, prompt, json: args.json, yes: args.yes, plan: args.plan });
+    // A one-shot run ends here, whatever handle something left open.
+    process.stdout.write('', () => process.exit(code));
+    return;
+  }
+
   // Update before the session starts, not after it ends.
   //
   // Installing in the background and taking effect "next time" means the run