codeply-cli 0.5.3 → 0.5.5

package/lib/agent.mjs

@@ -40,7 +40,7 @@ const MAX_MALFORMED_RETRIES = 3;
 const CONTEXT_CHAR_BUDGET = 64000;
 function contextBudgetFor(route) {
   if (route && route.custom) return route.custom.kind === 'ollama' ? 100000 : 200000;
-  if (route && route.auto) return 160000; // Gemma 4 31B on Ollama Cloud has a large window
+  if (route && route.auto) return 160000; // about 40k tokens: keeps Auto's Claude steps cheap (Haiku 5.5 costs 5x past 100k)
   return CONTEXT_CHAR_BUDGET;
 }
 
@@ -52,7 +52,7 @@ const FORMAT_CORRECTION =
   'closing tags complete:\n\n' +
   '<codeply:read_file>\n<path>run.html</path>\n</codeply:read_file>\n\n' +
   'Valid names: todo, ask_user, mcp, list_dir, read_file, write_file, edit_file, search, run, use_skill, list_skills, fetch_image, ' +
-  'browser_check, gmail_send, gmail_search, gmail_draft, drafts_list, calendar_list, calendar_add, slack_post_message, vercel_deploy, supabase_create_project, ' +
+  'browser_check, gmail_send, gmail_search, gmail_draft, drafts_list, calendar_list, calendar_add, add_model, slack_post_message, vercel_deploy, supabase_create_project, ' +
   'supabase_delete_project, github_create_repo, design_reference_search, view_images, supabase_api, supabase_sql, vercel_api, ' +
   'web_fetch, web_search, image_search, reach_me, watch_email, apply_patch, plan_exit, plan_enter, lsp, publish_check, publish_connect, supabase_setup, supabase_schema, ' +
   'publish_deploy, publish_github.';
@@ -329,6 +329,7 @@ const PARAMS = {
   drafts_list: [],
   calendar_list: ['from', 'to', 'max'],
   calendar_add: ['title', 'start', 'end', 'description', 'location', 'reminders'],
+  add_model: ['name', 'base_url', 'model', 'api_key'],
   slack_post_message: ['channel', 'text'],
   vercel_deploy: ['path'],
   supabase_create_project: ['name'],
@@ -865,6 +866,16 @@ drafts; gmail_send with <draft>id</draft> sends one of them.)
 <reminders>30</reminders>
 </codeply:calendar_add>
 
+<codeply:add_model>
+<name>GPT-5 mini</name>
+<base_url>https://api.openai.com/v1</base_url>
+<model>gpt-5-mini</model>
+<api_key>the key the user gave</api_key>
+</codeply:add_model>
+
+(add_model puts a model in the user's model menu when they ask; it asks them
+first, tests it, selects it and syncs it to their phone. Never repeat the key.)
+
 (Calendar times are the user's local time: 2026-10-06T15:30 for a time,
 2026-10-06 for a whole day; from/to also take today or tomorrow. calendar_list
 defaults to today. calendar_add puts a real event on the user's Google
@@ -1043,7 +1054,8 @@ RULES
 - Tool results are the only source of truth about what happened. A failed result (non-2xx status, non-zero exit code, "did not apply") means it did not happen - never describe it as done.
 - Creating a remote repo, pushing code, enabling Pages, or deploying anything are exactly the kind of claim covered by "never report success you did not verify" above - and the easiest one to get wrong, because each step's own command can silently no-op or partially fail while a LATER step still appears to succeed. Concretely: run whoami equivalents (gh api user, gh auth status) to get the real signed-in username BEFORE building any URL with it - never guess a username from the OS account name, the folder name, or anything the user said earlier that could be stale; after gh repo create or git push, treat the command's own exit code and printed output as the only source of truth for whether it worked, not your prior turn's summary of what you intended to do - a command you ran two turns ago having succeeded is not evidence this turn's retry did too; and never hand the user a repository/deployment URL you have not just confirmed resolves (curl -I it, or read it back from the command's own output) - a plausible-looking URL built from a guessed username/slug is a fabrication even if the pattern is usually right.
 - gmail_send and slack_post_message send a real email or a real Slack message the moment they run - there is no "preview" mode. Only use them when the user actually asked for that email/message to go out, never speculatively, never as a way to "show" them what it would say. When the user wants an email written but not sent yet, use gmail_draft instead. The user sees the email on an editable card before it goes out and may change it: the tool result says what was really sent or saved, so report that, not your original wording. calendar_add likewise puts a real event on the user's Google Calendar: only when they asked for it, with times in their local time; check calendar_list first when they ask what is on their calendar or whether a time is free. If gmail_search or a prior message makes clear Gmail/Slack isn't connected, say so plainly and stop - do not retry hoping it connects itself, and do not claim you sent something when the tool reported it wasn't connected.
-- vercel_deploy, supabase_create_project, supabase_delete_project, and github_create_repo are the same category as gmail_send/slack_post_message above: real, immediate action the moment they run - a live production deployment, a newly provisioned cloud database with its own bill, a brand-new repository pushed with the user's code. Only use them when the user actually asked for that outcome, never speculatively "to check if it would work." If one reports its integration isn't connected, say so plainly and stop rather than retrying or working around it. supabase_delete_project is the sharpest of these - it permanently destroys a database with no undo - so only reach for it when the user has clearly asked to delete or remove a specific project, never as cleanup for something that merely looks unused.
+- A brand-new project: when the user asks you to start, create or build a new app or project from scratch (an empty or new folder), then once the first version runs, back it up on GitHub without being asked again: call github_create_repo (it creates a private repo on their connected account and pushes; the user approves it on a card, no env vars, tokens or github.com steps). If it reports GitHub isn't connected, mention once, in one line, that connecting GitHub in Connect Apps backs projects up automatically, and carry on. Don't do this for existing projects, folders that are already git repos with a remote, or small one-off files.
+- vercel_deploy, supabase_create_project, supabase_delete_project, and github_create_repo are the same category as gmail_send/slack_post_message above: real, immediate action the moment they run - a live production deployment, a newly provisioned cloud database with its own bill, a brand-new repository pushed with the user's code. Only use them when the user actually asked for that outcome (or, for github_create_repo, a brand-new project as described above), never speculatively "to check if it would work." If one reports its integration isn't connected, say so plainly and stop rather than retrying or working around it. supabase_delete_project is the sharpest of these - it permanently destroys a database with no undo - so only reach for it when the user has clearly asked to delete or remove a specific project, never as cleanup for something that merely looks unused.
 - Images: build without photos first. Most pages look great with type, color, layout, CSS shapes, icons and inline SVG, so do that unless the design truly needs a photo (a restaurant's food, a product shot, a portfolio). Never ask the user for images or how imagery should work; decide yourself. When a photo is genuinely needed, find a real one with image_search (it searches the whole web like Google Images), pick the result that fits that exact section, and download it with fetch_image to a path under assets/. Every image in the markup must be that local file: never point an <img> or CSS background at a remote URL, and never use loremflickr, picsum or other random-photo services. If a downloaded image turns out broken or unrelated once you look at the page, delete it and pick another result.
 - If a SKILLS entry below is a clear match for the task, use_skill it before starting - its instructions take priority over your own default approach for that kind of work. Do not use_skill speculatively; only when a listed skill actually matches what you are about to do. A name under LIKELY RELEVANT TO THIS REQUEST, if that section is present, was matched against your actual request from the full library - treat it exactly the same way: use_skill it before starting unless it's obviously a false match, do not silently ignore it in favor of guessing your own approach.
 - EXCEPTION - this one is not speculative: if the task is to build or restyle any page a human will look at in a browser (a landing page, a small-business site, a portfolio, a dashboard, any HTML/CSS/UI), use_skill 'premium-web-design' before writing markup, even if the brief sounds tiny or mundane ("a site for a tea shop"). A plain-sounding brief is not permission for a flat, default-Bootstrap-looking result - Codeply's bar is that every generated page reads as deliberately designed. Skip this only if the user explicitly asked for something minimal/utilitarian/no-frills.
@@ -1429,7 +1441,7 @@ const NO_NATIVE_TOOLS_REMINDER =
 // unless their entry says toolMode: 'text', or CODEPLY_TOOLS=text is set.
 // A model that rejects tools is remembered for the rest of the session.
 const nativeUnsupported = new Set();
-const MUTATING_ACTIONS = new Set(['write_file', 'edit_file', 'apply_patch', 'fetch_image', 'gmail_send', 'gmail_draft', 'calendar_add', 'slack_post_message', 'vercel_deploy', 'supabase_create_project', 'supabase_delete_project', 'github_create_repo', 'supabase_setup', 'supabase_schema', 'publish_deploy', 'publish_github']);
+const MUTATING_ACTIONS = new Set(['write_file', 'edit_file', 'apply_patch', 'fetch_image', 'gmail_send', 'gmail_draft', 'calendar_add', 'add_model', 'slack_post_message', 'vercel_deploy', 'supabase_create_project', 'supabase_delete_project', 'github_create_repo', 'supabase_setup', 'supabase_schema', 'publish_deploy', 'publish_github']);
 
 /**
  * Native function names for MCP tools (mcp__server__tool, within the 64-char

package/lib/ai.js

@@ -289,6 +289,7 @@ async function chatViaProxy(messages, opts) {
           'Content-Type': 'application/json',
           'Authorization': `Bearer ${token}`,
           'apikey': SUPABASE_ANON_KEY,
+          ...(deviceId() ? { 'x-codeply-device': deviceId() } : {}),
         },
         // meta is optional, display-only context (what was asked, which file) -
         // the proxy logs it to usage_history so CLI activity shows up in the
@@ -1223,14 +1224,88 @@ async function testModel(m) {
 }
 
 // ─── Auto ───────────────────────────────────────────────────────────────────
-// "Auto" is Gemma 4 31B on Ollama Cloud. Two account keys back it (a release
-// build bakes OLLAMA_API_KEY / OLLAMA_API_KEY_FALLBACK in via
-// scripts/embed-secrets.js; from source they come from ~/.codeply/config.json).
-// chatViaOllama moves to the second key the moment the first is over quota or
-// failing. Only if no key works at all does it fall back to the hosted proxy.
+// "Auto" is Codeply's router (Codeply-App/supabase/functions/auto): Claude
+// Sonnet 5.5 for coding and hard work, Claude Haiku 5.5 for chat, images and
+// background jobs, gpt-oss-120b and Gemma 4 when a daily allowance is used up.
+// It decides per turn on the server, where the Claude key and the budgets
+// live. If the router can't be reached at all, Auto falls back to Gemma 4 31B
+// on Ollama Cloud directly (two account keys: a release build bakes
+// OLLAMA_API_KEY / OLLAMA_API_KEY_FALLBACK in via scripts/embed-secrets.js;
+// from source they come from ~/.codeply/config.json), then the hosted proxy.
+const AUTO_URL = `${SUPABASE_URL}/functions/v1/auto`;
 const AUTO_MODEL = { host: 'https://ollama.com', model: 'gemma4:31b' };
+// Long Claude turns: the router streams keep-alive spaces, so allow a while
+const AUTO_TIMEOUT_MS = 6 * 60_000;
+
+/**
+ * This computer, as a one-way hash, so the router can give one Claude
+ * allowance per computer however many accounts sign in on it. Built from the
+ * OS machine id (Windows MachineGuid, the Mac's hardware UUID, Linux
+ * /etc/machine-id), or the first network card's MAC when that can't be read.
+ * The raw values never leave the PC.
+ */
+let deviceIdCache = null;
+function deviceId() {
+  if (deviceIdCache !== null) return deviceIdCache;
+  const os = require('os');
+  const { execSync } = require('child_process');
+  let machine = '';
+  try {
+    if (process.platform === 'win32') {
+      const out = execSync('reg query HKLM\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid', { encoding: 'utf8', windowsHide: true, timeout: 3000 });
+      machine = (/MachineGuid\s+REG_SZ\s+(\S+)/.exec(out) || [])[1] || '';
+    } else if (process.platform === 'darwin') {
+      const out = execSync('ioreg -rd1 -c IOPlatformExpertDevice', { encoding: 'utf8', timeout: 3000 });
+      machine = (/"IOPlatformUUID" = "([^"]+)"/.exec(out) || [])[1] || '';
+    } else {
+      machine = require('fs').readFileSync('/etc/machine-id', 'utf8').trim();
+    }
+  } catch {}
+  const macs = Object.values(os.networkInterfaces()).flat()
+    .filter((n) => n && !n.internal && n.mac && n.mac !== '00:00:00:00:00:00')
+    .map((n) => n.mac).sort();
+  const raw = machine || macs[0] || '';
+  deviceIdCache = raw ? require('crypto').createHash('sha256').update(`codeply-device|${raw}`).digest('hex') : '';
+  return deviceIdCache;
+}
+
+async function chatViaRouter(messages, opts) {
+  const token = await getAccessToken();
+  // A cloud run has no sign-in: its usage key (CODEPLY_TRACK_KEY) stands in for the person
+  const trackKey = token ? '' : String(process.env.CODEPLY_TRACK_KEY || '').trim();
+  const device = trackKey ? '' : deviceId();
+  if (!token && !trackKey) return { success: false, unreachable: true, error: 'Not signed in.' };
+  return withRetries(async () => {
+    let res, body;
+    const { signal, isTimeout, cleanup } = withTimeout(opts.signal, AUTO_TIMEOUT_MS);
+    try {
+      res = await fetch(AUTO_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : { 'x-codeply-track-key': trackKey }), apikey: SUPABASE_ANON_KEY, ...(device ? { 'x-codeply-device': device } : {}) },
+        body: JSON.stringify({
+          messages: wireMessages(messages),
+          ...(opts.tools ? { tools: opts.tools } : {}),
+          opts: { json: !!opts.json, maxTokens: opts.maxTokens, temperature: opts.temperature },
+        }),
+        signal,
+      });
+      body = JSON.parse((await res.text()).trim() || '{}');
+    } catch (e) {
+      if (isAbortError(e) && !isTimeout()) return { aborted: true };
+      return { retryable: true, error: isTimeout() ? 'Auto took too long to answer.' : e.message };
+    } finally {
+      cleanup();
+    }
+    if (body.success) return { done: true, value: { success: true, data: body.data, modelUsed: body.modelUsed, route: body.route } };
+    if (body.error) return { done: true, value: { success: false, error: body.error } };
+    return { retryable: isTransientStatus(res.status), retryAfterMs: retryAfterMs(res), error: describeStatus(res.status) };
+  }, opts.signal);
+}
 
 async function chatViaAuto(messages, opts) {
+  const routed = await chatViaRouter(messages, opts);
+  if (routed.success || routed.aborted) return routed;
+  // The router itself is unreachable or broken: the old direct route still works.
   const cfg = getConfig();
   const keys = { apiKey: cfg.ollama.apiKey, apiKeyFallback: cfg.ollama.apiKeyFallback };
   if (!keys.apiKey && !keys.apiKeyFallback) return chatViaProxy(messages, opts);
@@ -1260,6 +1335,10 @@ async function chatResearch(messages, opts, rm) {
   const rmod = researchMode();
   const target = rmod.resolveTarget(rm);
   if (target.error) return { success: false, error: target.error };
+  // Online without their own key runs on Codeply's Ollama account: signed-in people only
+  if (rm.mode !== 'local' && !String(rm.apiKey || '').trim() && !(await getAccessToken().catch(() => null))) {
+    return { success: false, error: 'Sign in to Codeply to use Research Mode online, or add your own Ollama key in its settings.' };
+  }
   if (!rm.model) return { success: false, error: 'Pick a model in Research Mode settings.' };
   const pre = rmod.preprocess({ messages, mode: rm.mode, model: rm.model, researchContext: rm.context });
   return chatViaOllamaNative(rmod.withSystem(pre), opts, { baseUrl: target.host, model: rm.model, apiKey: target.apiKey, research: rm.mode === 'cloud' ? 'cloud' : 'local' });
@@ -1267,8 +1346,6 @@ async function chatResearch(messages, opts, rm) {
 
 /** Which route a request takes, for the usage counts (telemetry.js). */
 function providerOf(opts) {
-  const rm = getConfig().research;
-  if (rm && rm.enabled) return 'research';
   if (opts.route && opts.route.custom) return opts.route.custom.kind === 'chatgpt' ? 'chatgpt' : opts.route.custom.kind === 'ollama' ? 'ollama' : 'byok';
   if (opts.route && opts.route.auto) return 'auto';
   const p = applyRoute(getConfig(), opts.route).provider;
@@ -1290,9 +1367,13 @@ async function chat(messages, opts = {}) {
 }
 
 async function chatRouted(messages, opts = {}) {
-  // Research Mode, when switched on in settings, takes every request.
+  // Research Mode: the user's research context goes in front, and whatever
+  // model is selected (Auto or their own) answers as usual.
   const rm = getConfig().research;
-  if (rm && rm.enabled) return chatResearch(messages, opts, rm);
+  if (rm && rm.enabled && String(rm.context || '').trim()) {
+    const rmod = researchMode();
+    messages = rmod.withSystem(rmod.preprocess({ messages, researchContext: rm.context }));
+  }
   // A user-added model (desktop model picker) always wins when routed.
   if (opts.route && opts.route.custom) return chatViaCustom(messages, opts, opts.route.custom);
   // Auto in the desktop app = the hosted Codeply model, regardless of what

package/lib/cloud.mjs

@@ -104,6 +104,7 @@ jobs:
           CRAFT_ENGINE: \${{ vars.CRAFT_ENGINE }}
           CRAFT_ENV: \${{ secrets.CRAFT_ENV }}
           CRAFT_MERGE: \${{ vars.CRAFT_MERGE }}
+          CRAFT_PERMISSIONS: \${{ vars.CRAFT_PERMISSIONS }}
           CRAFT_BASE: \${{ github.ref_name }}
           CRAFT_PROMPT: \${{ inputs.prompt }}
           CRAFT_MODE: \${{ inputs.mode }}
@@ -379,14 +380,18 @@ export async function ensureMirror({ api, cwd, home = defaultHome() }) {
   throw new Error(`Could not find a free name for the mirror (tried ${base} to ${base}-9).`);
 }
 
-/** Which model the runner uses. Local models can't be reached from GitHub. */
+/**
+ * Which model a cloud run uses. Auto (Codeply's router, through the run's usage
+ * key, counted in the person's allowance) unless they picked one of their own
+ * models that GitHub can reach; a model on this PC (or with no key) uses Auto.
+ */
+export const AUTO_CLOUD = { kind: 'auto', model: 'Auto', sig: 'auto' };
 export function cloudModelConfig(model) {
-  if (!model || !model.model) return { error: 'Pick one of your own models first. Cloud runs use your key, not Auto.' };
+  if (!model || !model.model) return AUTO_CLOUD;
   const kind = model.kind === 'ollama' ? 'ollama' : 'openai';
   const baseUrl = kind === 'ollama' ? String(model.baseUrl || 'https://ollama.com').replace(/\/+$/, '').replace(/\/(api|v1)$/i, '') : String(model.baseUrl || '').trim();
-  if (!baseUrl) return { error: 'That model has no base URL.' };
-  if (/^https?:\/\/(localhost|127\.|0\.0\.0\.0|\[::1\]|192\.168\.|10\.|172\.(1[6-9]|2\d|3[01])\.)/i.test(baseUrl)) return { error: `${model.name || model.model} runs on this PC, so GitHub can't reach it. Pick a cloud model for cloud runs.` };
-  if (!model.apiKey) return { error: `${model.name || model.model} has no API key.` };
+  if (!baseUrl || !model.apiKey) return AUTO_CLOUD;
+  if (/^https?:\/\/(localhost|127\.|0\.0\.0\.0|\[::1\]|192\.168\.|10\.|172\.(1[6-9]|2\d|3[01])\.)/i.test(baseUrl)) return AUTO_CLOUD;
   return { kind, baseUrl, model: model.model, apiKey: model.apiKey, sig: crypto.createHash('sha256').update([kind, baseUrl, model.model, model.apiKey].join('\n')).digest('hex').slice(0, 16) };
 }
 
@@ -398,7 +403,13 @@ async function setVariable(api, repo, name, value) {
 /** Put the model key in the mirror's encrypted secrets and the rest in variables. */
 export async function configureModel({ api, repo, model }) {
   const cfg = cloudModelConfig(model);
-  if (cfg.error) throw new Error(cfg.error);
+  if (cfg.kind === 'auto') {
+    // Auto: no model key in the repo at all; the runner reaches Codeply's router with its usage key
+    await api('DELETE', `/repos/${repo}/actions/secrets/CODEPLY_API_KEY`, null, { allow: [404] });
+    for (const name of ['CODEPLY_BASE_URL', 'CODEPLY_MODEL']) await api('DELETE', `/repos/${repo}/actions/variables/${name}`, null, { allow: [404] });
+    await setVariable(api, repo, 'CODEPLY_MODEL_KIND', 'auto');
+    return cfg;
+  }
   const pk = (await api('GET', `/repos/${repo}/actions/secrets/public-key`)).json;
   await api('PUT', `/repos/${repo}/actions/secrets/CODEPLY_API_KEY`, { encrypted_value: sealSecret(pk.key, cfg.apiKey), key_id: pk.key_id });
   await setVariable(api, repo, 'CODEPLY_MODEL_KIND', cfg.kind);
@@ -467,8 +478,8 @@ export async function ensureTrackKey({ api, repo, cwd, home = defaultHome(), fet
   try {
     const p = getProject(cwd, home) || {};
     if (p.trackKeyRepo === repo) return false;
-    if (process.env.CODEPLY_TELEMETRY === '0') return false;
-    try { if (require('./config.js').getConfig().telemetry === false) return false; } catch {}
+    // Needed whatever the usage-stats setting: the run reaches Auto and the connected
+    // apps with it (telemetry.js still sends no stats when they're switched off).
     const auth = require('./auth.js');
     const token = await auth.getAccessToken().catch(() => null);
     if (!token) return false;
@@ -549,7 +560,7 @@ export async function loadCloudConnections({ env = process.env, fetchImpl = fetc
 }
 
 // Bumped when CLOUD_WORKFLOW changes, so repos set up earlier get the new file once.
-export const WORKFLOW_REV = 2;
+export const WORKFLOW_REV = 3;
 
 /**
  * One-click setup. With `target: 'repo'` (default when the project has a GitHub
@@ -578,7 +589,7 @@ export async function setupCloud({ cwd, token, model, target, envText, home = de
   }
   await configureModel({ api, repo, model });
   if (envText != null) await setProjectEnv({ api, repo, envText });
-  updateProject(cwd, home, (p) => ({ ...p, modelSig: cfg.sig, modelName: model.name || model.model, enabled: true, workflowRev: WORKFLOW_REV }));
+  updateProject(cwd, home, (p) => ({ ...p, modelSig: cfg.sig, modelName: cfg.kind === 'auto' ? 'Auto' : (model.name || model.model), enabled: true, workflowRev: WORKFLOW_REV }));
   await ensureTrackKey({ api, repo, cwd, home, fetchImpl });
   await syncCloudConnections({ home, fetchImpl });
   return { repo, created, kind, base, url: `${(serverUrl || 'https://github.com').replace(/\/$/, '')}/${repo}`, skipped };
@@ -629,12 +640,12 @@ export async function startCloudRun({ cwd, token, prompt, mode = 'Build', sessio
   if (prompt.length > MAX_PROMPT) throw new Error(`That task is too long for a cloud run (${prompt.length} characters, the limit is ${MAX_PROMPT}).`);
   mode = ['Build', 'Plan', 'Ask'].includes(mode) ? mode : 'Build';
   const api = githubApi({ token, apiUrl, fetchImpl });
-  if (model) {
+  // model: undefined leaves the repo's model as it is; null (Auto selected) or a model sets it
+  if (model !== undefined) {
     const cfg = cloudModelConfig(model);
-    if (cfg.error) throw new Error(cfg.error);
     if (cfg.sig !== p.modelSig) {
       await configureModel({ api, repo: p.repo, model });
-      updateProject(cwd, home, (q) => ({ ...q, modelSig: cfg.sig, modelName: model.name || model.model }));
+      updateProject(cwd, home, (q) => ({ ...q, modelSig: cfg.sig, modelName: cfg.kind === 'auto' ? 'Auto' : (model.name || model.model) }));
     }
   }
   const base = p.base || 'main';
@@ -681,6 +692,28 @@ export async function readTaskDoc(api, repo, taskId) {
 }
 
 /** Where a cloud task is: its status file first, then the workflow run (for starts and failed starts). */
+/** The person's answer to a cloud run's question (allow or not), picked up by the runner within seconds. */
+export async function answerCloudAsk({ cwd, token, taskId, askId, approve, home = defaultHome(), apiUrl, fetchImpl }) {
+  const task = getTask(cwd, taskId, home);
+  if (!task) throw new Error('Unknown cloud task.');
+  if (!/^[\w.-]+$/.test(String(askId || ''))) throw new Error('Unknown question.');
+  const api = githubApi({ token, apiUrl, fetchImpl });
+  const ok = await branchFiles(api, task.repo).write(SESSION_PATHS.answer(askId), { verdict: approve ? 'approve' : 'reject', at: Date.now() }, `Craft answer ${askId}`);
+  if (!ok) throw new Error('Could not send your answer to GitHub. Try again.');
+  saveTask(cwd, home, { ...task, ask: null });
+  return true;
+}
+
+/** "ask" (risky actions wait for an OK) or "full" (they just run), kept as the repo variable CRAFT_PERMISSIONS. */
+export async function setCloudPermission({ cwd, token, permission, home = defaultHome(), apiUrl, fetchImpl }) {
+  const p = getProject(cwd, home);
+  if (!p || !p.repo) throw new Error('Set up cloud runs for this project first.');
+  const value = permission === 'full' ? 'full' : 'ask';
+  await setVariable(githubApi({ token, apiUrl, fetchImpl }), p.repo, 'CRAFT_PERMISSIONS', value);
+  updateProject(cwd, home, (q) => ({ ...q, permission: value }));
+  return value;
+}
+
 export async function cloudRunStatus({ cwd, taskId, token, home = defaultHome(), apiUrl, fetchImpl, retryMs = 3000 }) {
   const task = getTask(cwd, taskId, home);
   if (!task) throw new Error('Unknown cloud task.');
@@ -695,6 +728,8 @@ export async function cloudRunStatus({ cwd, taskId, token, home = defaultHome(),
       const { id: _i, startedAt: _s, updatedAt: _u, runId: _r, ...result } = rest;
       Object.assign(next, { status, result, error: result.error || null, finishedAt: Date.now(), queued: false });
     } else next.status = 'running';
+    // a risky action waiting for the person's OK (answerCloudAsk)
+    next.ask = next.status === 'running' && doc.ask && doc.ask.id ? doc.ask : null;
     saveTask(cwd, home, next);
     return { ...next, events };
   }
@@ -950,6 +985,8 @@ export const SESSION_PATHS = {
   live: (sid) => `live/${sid}.json`,
   queue: (sid) => `queue/${sid}`,
   shot: (id, n) => `shots/${id}/${n}.png`,
+  // A risky action waiting for the person: Craft or the phone writes the answer here.
+  answer: (askId) => `answers/${askId}.json`,
   // What does not fit in the workflow's inputs (a bot's prompt), written before the dispatch.
   request: (id) => `requests/${id}.json`,
 };
@@ -1121,7 +1158,8 @@ async function runOneTask({ task, env, cwd, api, files, repo, token, serverUrl,
     output: { title: 'Starting', summary: 'Starting...' },
   }).catch(() => ({ json: null }))).json : null;
 
-  const statusDoc = (status, extra = {}) => ({ id: taskId, status, mode, prompt: prompt.slice(0, 4000), sessionId, ...(kind === 'task' ? { kind } : {}), ...(bot ? { bot: { name: bot.name } } : {}), startedAt, updatedAt: Date.now(), runId: env.GITHUB_RUN_ID || null, ...extra });
+  let pendingAsk = null; let asks = 0;
+  const statusDoc = (status, extra = {}) => ({ ...(pendingAsk && status === 'running' ? { ask: pendingAsk } : {}), id: taskId, status, mode, prompt: prompt.slice(0, 4000), sessionId, ...(kind === 'task' ? { kind } : {}), ...(bot ? { bot: { name: bot.name } } : {}), startedAt, updatedAt: Date.now(), runId: env.GITHUB_RUN_ID || null, ...extra });
   const finish = async (ok, title, summary, result) => {
     const baseLen = JSON.stringify(result).length;
     const packed = packEvents(events, Math.max(4000, MAX_OUTPUT - baseLen - 200));
@@ -1169,7 +1207,31 @@ async function runOneTask({ task, env, cwd, api, files, repo, token, serverUrl,
     const taskBase = await git(cwd, ['rev-parse', 'HEAD']).catch(() => headSha);
     const hist = await loadHistory(files, sessionId);
     await pushProgress(hist.messages.length ? `Continuing the chat (${hist.messages.length / 2} earlier turns).` : 'Working on it.', true);
-    const approve = ciApprove(cwd);
+    // Risky actions (deploys...) ask the person unless the repo's Cloud permission is "full".
+    const ASK_WAIT_MS = 15 * 60 * 1000;
+    // Only a repo with the current workflow passes CRAFT_PERMISSIONS (empty when unset): its
+    // Craft and phone can show the question. An older setup keeps the old rule (no) until updated.
+    const rules = ciApprove(cwd, { permission: env.CRAFT_PERMISSIONS, canAsk: env.CRAFT_PERMISSIONS !== undefined });
+    const approve = async (req) => {
+      const v = await rules(req);
+      if (v !== 'ask') return v;
+      const askId = `${taskId}-${++asks}`;
+      pendingAsk = { id: askId, tool: req.tool, title: String(req.title || req.tool).slice(0, 300), detail: String(req.detail || '').slice(0, 2000), at: Date.now() };
+      events.push({ t: 'notice', level: 'info', text: `Waiting for your OK: ${pendingAsk.title}` });
+      await pushProgress('Waiting for your OK.', true);
+      const until = Date.now() + ASK_WAIT_MS;
+      let verdict = null;
+      while (Date.now() < until && !verdict) {
+        await sleep(4000);
+        const f = await files.read(SESSION_PATHS.answer(askId)).catch(() => null);
+        if (f && f.json) { verdict = f.json.verdict === 'approve' ? 'once' : 'reject'; files.remove(SESSION_PATHS.answer(askId), f.sha).catch(() => {}); }
+        else if (heartbeat) heartbeat(true).catch(() => {});
+      }
+      pendingAsk = null;
+      events.push({ t: 'notice', level: 'info', text: verdict === 'once' ? 'Approved.' : verdict === 'reject' ? 'You said no, so it was skipped.' : 'No answer in 15 minutes, so it was skipped.' });
+      await pushProgress('Working.', true);
+      return verdict || 'reject';
+    };
     let answer = ''; let steps = 0; let failure = '';
     const userMessage = kind === 'task'
       ? `${prompt}\n\n(You are running unattended in Codeply Cloud on a Linux machine, not on the user's PC: you cannot reach their local files or desktop apps. Use the shell, the web and this repository. Nobody can answer questions mid-run, so make sensible choices and say what you assumed. Your final reply is read out to the user: say plainly what you did or found, in a few short sentences, no markdown. Do not commit or push; Craft does that when you finish.)`

package/lib/config.js

@@ -102,9 +102,9 @@ function getConfig() {
   const fr = file.research || {};
   const research = {
     enabled: fr.enabled === true,
-    mode: fr.mode === 'cloud' ? 'cloud' : 'local',
+    mode: fr.mode === 'local' ? 'local' : 'cloud', // online by default: works with no Ollama installed
     model: String(fr.model || ''),
-    apiKey: process.env.OLLAMA_API_KEY || fr.apiKey || '',
+    apiKey: fr.apiKey || '', // only a key the person added; without one, research-mode/ollama.js uses Codeply's
     context: String(fr.context || ''),
   };
 

package/lib/github-agent.mjs

@@ -42,6 +42,12 @@ export const PROVIDERS = {
 
 /** Model route from CODEPLY_PROVIDER / CODEPLY_BASE_URL / CODEPLY_MODEL / CODEPLY_API_KEY. */
 export function routeFromEnv(env) {
+  const wantsAuto = String(env.CODEPLY_MODEL_KIND || '').toLowerCase() === 'auto';
+  const hasKey = !!String(env.CODEPLY_API_KEY || '').trim();
+  if (wantsAuto || (!hasKey && !env.CODEPLY_BASE_URL && env.CODEPLY_TRACK_KEY)) {
+    if (!env.CODEPLY_TRACK_KEY) return { error: 'This repo has no Codeply usage key yet. Set cloud up again from Codeply.' };
+    return { route: { auto: true } };
+  }
   const provider = String(env.CODEPLY_PROVIDER || 'openai').toLowerCase();
   const preset = PROVIDERS[provider];
   const baseUrl = env.CODEPLY_BASE_URL || (preset && preset.baseUrl);
@@ -121,12 +127,21 @@ export function git(cwd, args, { auth, input } = {}) {
 const slug = (s) => String(s || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 30) || 'change';
 export const clip = (s) => (s.length > MAX_COMMENT ? `${s.slice(0, MAX_COMMENT)}\n\n[... cut, the run log has the rest]` : s);
 
-/** The approver for an unattended run: rules file first, then no pushing, no dangerous commands. */
-export function ciApprove(cwd) {
+/**
+ * The approver for a run nobody is watching live: the rules file first, never a
+ * git push (Craft pushes when the run ends), then the risky actions (deploys,
+ * deleting a database, risky commands). Those depend on the repo's Cloud
+ * permission (CRAFT_PERMISSIONS): "full" runs them, anything else answers
+ * 'ask' so the cloud runner can ask the person in Craft or on the phone. With
+ * no way to ask (the /codeply comment agent), 'ask' means no.
+ */
+export function ciApprove(cwd, { permission = '', canAsk = false } = {}) {
+  const full = String(permission || '').toLowerCase() === 'full';
   return async (req) => {
     const d = permissions.decide(req, cwd);
-    if (d.decision === 'deny' || req.danger || req.tool === 'fetch_image') return 'reject';
+    if (d.decision === 'deny' || req.tool === 'fetch_image') return 'reject';
     if (req.tool === 'run' && /(^|[\s;&|(])(git\b[^;&|\n]*\spush|gh)(\s|$)/.test(`${req.detail || ''}\n${req.title || ''}`)) return 'reject';
+    if (req.danger) return full ? 'once' : canAsk ? 'ask' : 'reject';
     return 'once';
   };
 }

package/lib/native-tools.mjs

@@ -38,6 +38,7 @@ export const TOOL_DOCS = {
   drafts_list: { d: 'List the drafts saved in Codeply (ids, subject, recipient). Send one with gmail_send and its id as draft.', req: [], p: {} },
   calendar_list: { d: 'List events on the user\'s Google Calendar in a time range (default: today). Times are local.', req: [], p: { from: 'Start: today, tomorrow, 2026-10-03 or 2026-10-03T14:00. Default today.', to: 'End (a date means through that whole day). Default: end of the from day.', max: 'Most events to return (1-50, default 20).' } },
   calendar_add: { d: 'Add an event to the user\'s Google Calendar (asks the user first).', req: ['title', 'start'], p: { title: 'Event title.', start: 'Local start: 2026-10-03T14:00, or 2026-10-03 for an all-day event.', end: 'Local end. Default: one hour after start (all-day: the same day).', description: 'Notes for the event.', location: 'Where it is.', reminders: 'Popup reminders, minutes before, comma-separated, e.g. "10,60".' } },
+  add_model: { d: 'Add a model to the user\'s Codeply model menu when they ask (they give a name, base URL, model id and API key). Asks them first, tests it, saves it on this computer, selects it and syncs it to their phone. Any OpenAI-compatible API works; Ollama on this computer is http://localhost:11434 with no key.', req: ['base_url', 'model'], p: { name: 'Display name, e.g. "GPT-5 mini". Default: the model id.', base_url: 'OpenAI-compatible base URL, e.g. https://api.openai.com/v1, https://api.deepseek.com, https://openrouter.ai/api/v1.', model: 'The model id the provider expects, e.g. gpt-5-mini, deepseek-chat.', api_key: 'The API key the user gave (leave empty for a server with no key).' } },
   slack_post_message: { d: 'Post a real Slack message now. Only when the user asked for it.', req: ['channel', 'text'], p: { channel: 'Channel name or id.', text: 'Message text.' } },
   vercel_deploy: { d: 'Deploy a folder to the connected Vercel account (live, real).', req: [], p: { path: 'Folder to deploy. Default ".".' } },
   supabase_create_project: { d: 'Create a new Supabase project (billable, real).', req: ['name'], p: { name: 'Project name.' } },

package/lib/telemetry.js

@@ -47,7 +47,10 @@ function push(ev) {
 }
 
 /** One model call: { model, provider, tokens_in, tokens_out, ms }. */
-function recordAi(ev) { push({ kind: 'ai', ...ev }); }
+function recordAi(ev) {
+  if (ev && ev.model === 'fake') return; // the engine tests' stand-in model is not real use
+  push({ kind: 'ai', ...ev });
+}
 
 /** The app was opened (counts active users even on a day with no AI call), once an hour at most. */
 const lastOpen = new Map();

package/lib/tools.mjs

@@ -1335,13 +1335,23 @@ async function github_create_repo(args, ctx) {
     // at least one commit - a brand-new GitHub repo (created with no
     // auto_init below) starts completely empty, so pushing an empty local
     // repo would just fail with "src refspec main does not match any".
+    try { await runGit('--version', root); } catch {
+      return { ok: false, output: 'Git is not installed on this computer, so the code can\'t be pushed. Tell the user to install it from git-scm.com (the defaults are fine), then ask again.' };
+    }
     const isRepo = fs.existsSync(path.join(root, '.git'));
     if (!isRepo) await runGit('init', root);
     let hasCommit = true;
     try { await runGit('rev-parse HEAD', root); } catch { hasCommit = false; }
     if (!hasCommit) {
       await runGit('add -A', root);
-      await runGit('commit -m "Initial commit"', root);
+      // A computer where git was never told who you are would fail here
+      // ("Please tell me who you are"): commit as the GitHub account, with
+      // GitHub's private no-reply address. The git settings stay untouched.
+      const login = String(github.userName || 'codeply').replace(/[^A-Za-z0-9-]/g, '') || 'codeply';
+      let who = '';
+      try { await runGit('config user.name', root); } catch { who += `-c user.name="${login}" `; }
+      try { await runGit('config user.email', root); } catch { who += `-c user.email="${login}@users.noreply.github.com" `; }
+      await runGit(`${who}commit -m "Initial commit"`, root);
     }
 
     const repo = await oauth.githubCreateRepo(github.accessToken, repoName, { private: true });
@@ -2237,6 +2247,48 @@ const publishTools = publishLib.makePublishTools({
   resolveDir: (p, cwd) => resolvePath(String(p).trim(), cwd).abs,
 });
 
+/**
+ * add_model: adds a model to the user's model menu from chat ("add this model:
+ * name, base URL, API key"). Asks first (key masked), checks the model really
+ * answers, saves it on this computer and selects it. In Craft the desktop does
+ * the saving (globalThis.__codeplyHost.addModel), so it also syncs to the
+ * phone like any added model and the menu updates right away.
+ */
+async function add_model(args, ctx) {
+  const name = String(args.name || '').trim();
+  const baseUrl = String(args.base_url || args.baseUrl || '').trim().replace(/\/+$/, '');
+  const model = String(args.model || '').trim();
+  const apiKey = String(args.api_key || args.apiKey || '').trim();
+  if (!model) return { ok: false, output: 'add_model needs <model>: the model id the provider expects (e.g. gpt-4o-mini, claude-sonnet-5-5, deepseek-chat).' };
+  if (!/^https?:\/\//i.test(baseUrl)) return { ok: false, output: 'add_model needs <base_url> starting with http:// or https:// (e.g. https://api.openai.com/v1).' };
+  const local = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/i.test(baseUrl) && /:11434$/.test(baseUrl);
+  const shown = name || model;
+  const masked = apiKey ? `${apiKey.slice(0, 4)}…${apiKey.slice(-4)}` : 'none';
+  const verdict = readVerdict(await ctx.approve({
+    tool: 'add_model',
+    title: `Add "${shown}" to your models`,
+    detail: `Model: ${model}\nAddress: ${baseUrl}\nKey: ${masked}\n\nIt's tested first, saved on this computer, and synced to your phone.`,
+    danger: false,
+  }));
+  if (verdict.action === 'reject') return { ok: false, output: `User declined to add "${shown}".`, meta: { rejected: true } };
+  const input = { kind: local ? 'ollama' : 'openai', name: shown, baseUrl, model, apiKey };
+  try {
+    const host = globalThis.__codeplyHost;
+    let r;
+    if (host && typeof host.addModel === 'function') r = await host.addModel(input);
+    else {
+      const t = await require('./ai.js').testModel(input);
+      if (!t.ok) return { ok: false, output: `The model didn't answer, so it wasn't added: ${t.error}` };
+      r = config.saveModel({ ...input, phone: true });
+      if (r.ok) config.selectModel(r.model.id);
+    }
+    if (!r || !r.ok) return { ok: false, output: `Couldn't add it: ${(r && r.error) || 'unknown error'}` };
+    return { ok: true, output: `Added "${shown}" (${model} at ${baseUrl}) and selected it. It answered a test request${local ? '' : ' and syncs to the phone'}. Never repeat the API key back to the user.`, meta: { label: shown } };
+  } catch (e) {
+    return { ok: false, output: `Couldn't add it: ${e.message}` };
+  }
+}
+
 export const TOOLS = {
   ...publishTools,
   todo,
@@ -2246,14 +2298,14 @@ export const TOOLS = {
   web_fetch, web_search, image_search, apply_patch, plan_exit, plan_enter, lsp, reach_me, watch_email,
   list_dir, read_file, write_file, edit_file, search, run, use_skill, list_skills, fetch_image, browser_check,
   gmail_send, gmail_search, gmail_draft, drafts_list, calendar_list, calendar_add, slack_post_message, vercel_deploy, supabase_create_project, supabase_delete_project, github_create_repo,
-  design_reference_search, view_images, supabase_api, supabase_sql, vercel_api,
+  design_reference_search, view_images, supabase_api, supabase_sql, vercel_api, add_model,
 };
 
 // Tools that can change something. supabase_api/supabase_sql/vercel_api only
 // actually prompt for non-read requests (see above); read-only tools
 // (browser_check, gmail_search, design_reference_search, view_images, ...)
 // never prompt.
-export const TOOL_NEEDS_APPROVAL = new Set(['supabase_setup', 'supabase_schema', 'publish_deploy', 'publish_github', 'write_file', 'edit_file', 'apply_patch', 'run', 'fetch_image', 'gmail_send', 'gmail_draft', 'calendar_add', 'slack_post_message', 'vercel_deploy', 'supabase_create_project', 'supabase_delete_project', 'github_create_repo', 'supabase_api', 'supabase_sql', 'vercel_api']);
+export const TOOL_NEEDS_APPROVAL = new Set(['add_model', 'supabase_setup', 'supabase_schema', 'publish_deploy', 'publish_github', 'write_file', 'edit_file', 'apply_patch', 'run', 'fetch_image', 'gmail_send', 'gmail_draft', 'calendar_add', 'slack_post_message', 'vercel_deploy', 'supabase_create_project', 'supabase_delete_project', 'github_create_repo', 'supabase_api', 'supabase_sql', 'vercel_api']);
 
 /** Human-facing verb + colour hint for the transcript. */
 export const TOOL_DISPLAY = {
@@ -2286,6 +2338,7 @@ export const TOOL_DISPLAY = {
   drafts_list:{ verb: 'drafts', icon: '✉' },
   calendar_list:{ verb: 'calendar', icon: '▦' },
   calendar_add:{ verb: 'calendar', icon: '▦' },
+  add_model:{ verb: 'model', icon: '◆' },
   slack_post_message:{ verb: 'post', icon: '#' },
   vercel_deploy:{ verb: 'deploy', icon: '▲' },
   supabase_create_project:{ verb: 'provision', icon: '◆' },
@@ -2308,7 +2361,7 @@ export const TOOL_DISPLAY = {
 // agent.mjs; this covers every other tool that changes something outside the
 // conversation, so read-only can't be escaped through a side door.
 const MUTATING_TOOLS = new Set([
-  'write_file', 'edit_file', 'apply_patch', 'fetch_image', 'gmail_send', 'gmail_draft', 'calendar_add', 'slack_post_message',
+  'write_file', 'edit_file', 'apply_patch', 'fetch_image', 'gmail_send', 'gmail_draft', 'calendar_add', 'slack_post_message', 'add_model',
   'vercel_deploy', 'supabase_create_project', 'supabase_delete_project', 'github_create_repo',
   'supabase_setup', 'supabase_schema', 'publish_deploy', 'publish_github',
 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeply-cli",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Codeply from the terminal: an interactive AI coding agent, a local server (codeply serve), and a GitHub agent that runs in your own Actions runner.",
   "main": "bin/codeply.js",
   "bin": {