codeply-cli 0.5.1 → 0.5.2

package/lib/native-tools.mjs

@@ -32,8 +32,12 @@ export const TOOL_DOCS = {
   list_skills: { d: 'Search the full skill library.', req: ['query'], p: { query: 'One or two words.' } },
   fetch_image: { d: 'Download an image into the project.', req: ['url', 'path'], p: { url: 'Image URL.', path: 'Where to save it, e.g. assets/hero.jpg.' } },
   browser_check: { d: 'Open a page in a real browser and get errors plus a screenshot.', req: ['url'], p: { url: 'file:///absolute/path or http://localhost:port.', wait: 'Extra milliseconds to wait before capturing.', viewport: 'desktop (default), tablet, mobile, or WIDTHxHEIGHT.' } },
-  gmail_send: { d: 'Send a real email now (no drafts). Only when the user asked for it.', req: ['to', 'subject', 'body'], p: { to: 'Recipient address.', subject: 'Subject line.', body: 'Plain-text body.' } },
+  gmail_send: { d: 'Send a real email now. Only when the user asked for it to go out. The user sees it on an editable card first and may change it or save it as a draft instead; the result says what really happened.', req: [], p: { to: 'Recipient address.', subject: 'Subject line.', body: 'Plain-text body.', draft: 'Optional: the id of a draft saved in Codeply (from drafts_list) to send; to/subject/body then come from it.' } },
   gmail_search: { d: 'Search the connected Gmail account. Leave query empty to list the newest mail.', req: [], p: { query: 'Gmail search syntax, e.g. "is:unread" or "from:x@y.com". Empty = newest mail.' } },
+  gmail_draft: { d: 'Save an email as a draft without sending it: in Gmail\'s Drafts when Gmail is connected, otherwise in Codeply\'s own drafts.', req: [], p: { to: 'Recipient address (optional for a draft).', subject: 'Subject line.', body: 'Plain-text body.' } },
+  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".' } },
   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.' } },
@@ -44,7 +48,16 @@ export const TOOL_DOCS = {
   supabase_api: { d: 'Call the Supabase Management API.', req: ['method', 'path'], p: { method: 'GET, POST, PATCH, PUT or DELETE.', path: 'Path starting with /v1/.', body: 'JSON body.' } },
   supabase_sql: { d: 'Run SQL on a Supabase project database.', req: ['ref', 'query'], p: { ref: 'Project ref.', query: 'SQL.' } },
   vercel_api: { d: 'Call the Vercel REST API.', req: ['method', 'path'], p: { method: 'HTTP method.', path: 'Path like /v9/projects.', body: 'JSON body.' } },
+  publish_check: { d: 'Publishing only: read the project for publishing (stack, database signals, connections, earlier publishes).', req: [], p: { path: 'Folder to publish. Default ".".' } },
+  publish_connect: { d: 'Publishing only: ask the user to connect Supabase, Vercel or GitHub in one click and wait until it is connected.', req: ['service'], p: { service: 'supabase, vercel or github.', reason: 'One sentence on why it is needed, in plain words.' } },
+  supabase_setup: { d: 'Publishing only: pick (asks the user) or create a Supabase project, then write its URL and anon key into the app where its stack reads them.', req: [], p: { project: 'Optional: a project ref or name, or "new".', name: 'Name for a new project.', region: 'Region for a new project. Default us-east-1.' } },
+  supabase_schema: { d: 'Publishing only: run the SQL the app needs on its Supabase project. The user sees and approves it; RLS is turned on for new tables.', req: [], p: { sql: 'The SQL (tables plus RLS policies).', path: 'Or a .sql file in the project.', ref: 'Project ref. Default: the one from supabase_setup.' } },
+  publish_deploy: { d: 'Publishing only: deploy to Vercel (asks about GitHub before the first deploy), set env vars, wait until it is live and return the live URL.', req: [], p: { path: 'Folder to publish. Default ".".', name: 'Vercel project name. Default: the folder name or the earlier project.' } },
+  publish_github: { d: 'Publishing only, when the user wants GitHub: create or reuse the repo, push, and link it to Vercel so pushes deploy on their own.', req: [], p: { path: 'Folder. Default ".".', name: 'Repo name for a new repo.', private: '"false" for a public repo. Default private.' } },
   web_fetch: { d: 'Fetch a web page or API URL and get its content as readable text.', req: ['url'], p: { url: 'http:// or https:// URL.', format: '"text" (default, HTML converted to readable text), "html" or "raw".' } },
+  reach_me: { d: 'Reach the user on their phone: how=call rings their phone with your voice (only when it is urgent or they asked for a call), how=text sends a notification (anything else). Now, or later with at.', req: ['how', 'message'], p: { how: 'call or text.', message: 'What to tell them, short and specific.', at: 'Optional: when, like 17:30, 5pm, "in 20 minutes" or an ISO time. Empty means now.', bot: 'Optional: which of the user\'s bots it comes from, by name ("tell Shella to call me" means bot=Shella). Empty means you.' } },
+  watch_email: { d: 'Watch the inbox for an email from a sender and reach the user the moment one arrives (works in the background, also with Craft closed to the tray).', req: ['from', 'how'], p: { from: 'The email address, or a domain like example.com.', how: 'call or text, when it arrives.', note: 'Optional: what to say about it.', repeat: 'Optional: yes to alert on every email from them; default is once.' } },
+  image_search: { d: 'Search the whole web for real photos (like Google Images). Returns image URLs with sizes; download the one you pick with fetch_image.', req: ['query'], p: { query: 'What the photo should show.', num: 'Number of results (1-16, default 8).' } },
   web_search: { d: 'Search the web for current information (docs, errors, versions, news).', req: ['query'], p: { query: 'The search query.', num: 'Number of results (1-20, default 8).' } },
   apply_patch: { d: 'Change several files at once (add, update, delete, move) with one patch. Use it for multi-file changes; use edit_file for a single block.', req: ['patch'], p: { patch: 'The patch text: "*** Begin Patch", then "*** Add File: path" (lines start with +), "*** Update File: path" (optional "*** Move to: path", "@@ anchor line", then lines starting with " ", "-" or "+"), "*** Delete File: path", and "*** End Patch".' } },
   lsp: { d: 'Code navigation for TypeScript/JavaScript: find the real definition or every reference of a symbol, hover for its type, outline a file, or search symbols.', req: ['operation'], p: { operation: 'definition, references, implementation, hover, documentSymbol or workspaceSymbol.', path: 'File the symbol is in (not needed for workspaceSymbol).', line: '1-based line of the symbol.', character: '1-based column of the symbol (or give symbol instead).', symbol: 'The name on that line, e.g. fetchUser.', query: 'For workspaceSymbol: the name to look for.' } },
@@ -109,6 +122,8 @@ export function toNativeMessages(messages, parse, mcpToNative = null) {
       role: 'assistant',
       content: prose || '',
       tool_calls: withIds.map((c) => ({ id: c.id, type: 'function', function: nativeCall(c) })),
+      // DeepSeek's thinking mode rejects a tool call whose reasoning is missing.
+      ...(m.reasoning_content !== undefined ? { reasoning_content: m.reasoning_content } : {}),
     });
     // Collect everything up to the next assistant message.
     const answers = new Map();

package/lib/oauth-connectors.js

@@ -7,7 +7,23 @@
  * owns spinning that server up/down; this file only builds URLs and talks to
  * the providers' token/API endpoints. No secrets are ever logged.
  */
-const GMAIL_SCOPES = 'https://www.googleapis.com/auth/gmail.readonly https://www.googleapis.com/auth/gmail.send';
+// REST API hosts for Vercel, Supabase and GitHub. The environment overrides
+// exist only so the offline tests can point every call at fake local servers;
+// the app itself never sets them.
+const API = {
+  vercel: () => (process.env.CODEPLY_VERCEL_API || 'https://api.vercel.com').replace(/\/+$/, ''),
+  supabase: () => (process.env.CODEPLY_SUPABASE_API || 'https://api.supabase.com').replace(/\/+$/, ''),
+  github: () => (process.env.CODEPLY_GITHUB_API || 'https://api.github.com').replace(/\/+$/, ''),
+};
+
+// One Google connection covers Gmail (read, send, drafts) and Google
+// Calendar events. A connection made before compose/calendar were added lacks
+// them; the tools say "reconnect Gmail in Connect Apps" when Google refuses.
+const GOOGLE_SCOPE = {
+  compose: 'https://www.googleapis.com/auth/gmail.compose',
+  calendar: 'https://www.googleapis.com/auth/calendar.events',
+};
+const GMAIL_SCOPES = ['https://www.googleapis.com/auth/gmail.readonly', 'https://www.googleapis.com/auth/gmail.send', GOOGLE_SCOPE.compose, GOOGLE_SCOPE.calendar].join(' ');
 // channels:join is what lets slackPostMessage auto-join a public channel
 // before posting to it - without it, chat:write alone only covers channels
 // the app has already been manually invited into.
@@ -86,14 +102,14 @@ async function getGmailProfile(accessToken) {
  * per-error message so the real cause shows, with a plain-words hint for the
  * ones that need the user to act.
  */
-function gmailError(data, status, what) {
+function gmailError(data, status, what, scopeHint) {
   const err = (data && data.error) || {};
   const first = Array.isArray(err.errors) && err.errors[0] ? err.errors[0] : {};
   const reason = first.reason || err.status || '';
   const detail = [err.message, first.message].filter((m, i, a) => m && a.indexOf(m) === i).join(': ');
   let hint = '';
   if (status === 401) hint = ' The Gmail sign-in expired or was revoked. Reconnect Gmail in Connect Apps.';
-  else if (status === 403 && /scope|insufficient/i.test(detail + reason)) hint = ' Gmail was connected without read access. Reconnect Gmail in Connect Apps and allow all requested permissions.';
+  else if (status === 403 && /scope|insufficient/i.test(detail + reason)) hint = scopeHint || ' Gmail was connected without read access. Reconnect Gmail in Connect Apps and allow all requested permissions.';
   else if (status === 403 && /accessNotConfigured|SERVICE_DISABLED|has not been used/i.test(detail + reason)) hint = ' The Gmail API is not enabled on the Google Cloud project behind this app.';
   else if (/failedPrecondition|FAILED_PRECONDITION/i.test(reason)) hint = ' Google says this account has no usable Gmail mailbox for this app (Gmail turned off, or the account is not a test user of the app). Reconnect Gmail in Connect Apps with the right account.';
   else if (status === 400) hint = ' Reconnecting Gmail in Connect Apps usually fixes this.';
@@ -111,8 +127,24 @@ function base64UrlEncode(str) {
   return Buffer.from(str, 'utf8').toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
 }
 
+/**
+ * RFC 2822 message, base64url as Gmail wants it. A non-ASCII subject is RFC 2047 encoded.
+ * inReplyTo / references (Message-ID values) make it a reply in the same thread.
+ */
+function rawEmail({ to, subject, body, inReplyTo, references }) {
+  const s = String(subject || '');
+  const subj = /^[\x20-\x7e]*$/.test(s) ? s : `=?UTF-8?B?${Buffer.from(s, 'utf8').toString('base64')}?=`;
+  const oneLine = (v) => String(v || '').replace(/[\r\n]+/g, ' ').trim();
+  const head = [
+    to ? `To: ${oneLine(to)}` : '', `Subject: ${oneLine(subj)}`,
+    inReplyTo ? `In-Reply-To: ${oneLine(inReplyTo)}` : '', references ? `References: ${oneLine(references)}` : '',
+    'Content-Type: text/plain; charset="UTF-8"',
+  ].filter(Boolean).join('\r\n');
+  return base64UrlEncode(`${head}\r\n\r\n${body || ''}`);
+}
+
 async function gmailSend(accessToken, { to, subject, body }) {
-  const raw = base64UrlEncode(`To: ${to}\r\nSubject: ${subject}\r\nContent-Type: text/plain; charset="UTF-8"\r\n\r\n${body}`);
+  const raw = rawEmail({ to, subject, body });
   const res = await fetch('https://www.googleapis.com/gmail/v1/users/me/messages/send', {
     method: 'POST',
     headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
@@ -123,6 +155,66 @@ async function gmailSend(accessToken, { to, subject, body }) {
   return data; // { id, threadId, ... }
 }
 
+/** Saves a draft in the user's Gmail (needs gmail.compose). threadId + inReplyTo make it a reply in that thread. */
+async function gmailCreateDraft(accessToken, { to, subject, body, threadId, inReplyTo, references }) {
+  const message = { raw: rawEmail({ to, subject, body, inReplyTo, references }) };
+  if (threadId) message.threadId = String(threadId);
+  const res = await fetch('https://www.googleapis.com/gmail/v1/users/me/drafts', {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ message }),
+  });
+  const data = await readJson(res);
+  if (!res.ok) {
+    const e = gmailError(data, res.status, 'Gmail draft', ' Gmail was connected before drafts were allowed. Reconnect Gmail in Connect Apps to allow drafts.');
+    e.scopeMissing = res.status === 403 && /scope|insufficient/i.test(JSON.stringify(data));
+    throw e;
+  }
+  return data; // { id, message: { id, threadId } }
+}
+
+// ─── Google Calendar (same Google connection as Gmail) ──────────────────────
+const CALENDAR_EVENTS_URL = 'https://www.googleapis.com/calendar/v3/calendars/primary/events';
+
+function calendarError(data, status, what) {
+  const err = (data && data.error) || {};
+  const first = Array.isArray(err.errors) && err.errors[0] ? err.errors[0] : {};
+  const reason = first.reason || err.status || '';
+  const detail = [err.message, first.message].filter((m, i, a) => m && a.indexOf(m) === i).join(': ');
+  const text = `${detail} ${reason} ${JSON.stringify(err.details || '')}`;
+  let hint = '';
+  if (status === 401) hint = ' The Google sign-in expired or was revoked. Reconnect Gmail in Connect Apps.';
+  else if (status === 403 && /accessNotConfigured|SERVICE_DISABLED|has not been used|is disabled/i.test(text)) hint = ' The Google Calendar API is not enabled on the Google Cloud project behind this app. Enable "Google Calendar API" in that project (Google Cloud console, APIs & Services, Library), wait a minute, then try again.';
+  else if (status === 403 && /scope|insufficient/i.test(text)) hint = ' Google was connected before Calendar access was added. Reconnect Gmail in Connect Apps (it covers Calendar too) and allow calendar access.';
+  else if (status === 400) hint = ' Check the start and end times.';
+  const e = new Error(`${what} failed (HTTP ${status}${reason ? `, ${reason}` : ''}): ${detail || 'no details from Google'}.${hint}`);
+  e.status = status;
+  return e;
+}
+
+/** Events on the primary calendar between timeMin and timeMax (RFC 3339), soonest first. */
+async function calendarListEvents(accessToken, { timeMin, timeMax, maxResults = 20 }) {
+  const params = new URLSearchParams({ singleEvents: 'true', orderBy: 'startTime', maxResults: String(maxResults) });
+  if (timeMin) params.set('timeMin', timeMin);
+  if (timeMax) params.set('timeMax', timeMax);
+  const res = await fetch(`${CALENDAR_EVENTS_URL}?${params}`, { headers: { Authorization: `Bearer ${accessToken}` } });
+  const data = await readJson(res);
+  if (!res.ok) throw calendarError(data, res.status, 'Calendar list');
+  return data.items || [];
+}
+
+/** Creates an event on the primary calendar. `event` is a Calendar API event resource. */
+async function calendarInsertEvent(accessToken, event) {
+  const res = await fetch(CALENDAR_EVENTS_URL, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(event),
+  });
+  const data = await readJson(res);
+  if (!res.ok) throw calendarError(data, res.status, 'Calendar add');
+  return data; // { id, htmlLink, ... }
+}
+
 async function gmailSearch(accessToken, query, maxResults = 10) {
   // "*" and "" mean "everything" to a person but are not Gmail syntax; an
   // empty q simply lists the newest mail, which is what they meant.
@@ -242,7 +334,7 @@ function buildVercelAuthUrl(slug, state) {
 }
 
 async function exchangeVercelCode(clientId, clientSecret, code, redirectUri) {
-  const res = await fetch('https://api.vercel.com/v2/oauth/access_token', {
+  const res = await fetch(`${API.vercel()}/v2/oauth/access_token`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
     body: new URLSearchParams({ client_id: clientId, client_secret: clientSecret, code, redirect_uri: redirectUri }),
@@ -253,7 +345,7 @@ async function exchangeVercelCode(clientId, clientSecret, code, redirectUri) {
 }
 
 async function getVercelProfile(accessToken) {
-  const res = await fetch('https://api.vercel.com/v2/user', {
+  const res = await fetch(`${API.vercel()}/v2/user`, {
     headers: { Authorization: `Bearer ${accessToken}` },
   });
   const body = await res.json();
@@ -276,7 +368,7 @@ function buildSupabaseAuthUrl(clientId, redirectUri) {
 
 async function exchangeSupabaseCode(clientId, clientSecret, code, redirectUri) {
   const basic = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
-  const res = await fetch('https://api.supabase.com/v1/oauth/token', {
+  const res = await fetch(`${API.supabase()}/v1/oauth/token`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/x-www-form-urlencoded', Authorization: `Basic ${basic}` },
     body: new URLSearchParams({ code, grant_type: 'authorization_code', redirect_uri: redirectUri }),
@@ -299,7 +391,7 @@ async function vercelDeploy(accessToken, teamId, projectName, files) {
   // guess the framework unattended.
   const params = new URLSearchParams({ skipAutoDetectionConfirmation: '1' });
   if (teamId) params.set('teamId', teamId);
-  const res = await fetch(`https://api.vercel.com/v13/deployments${params.toString() ? `?${params}` : ''}`, {
+  const res = await fetch(`${API.vercel()}/v13/deployments${params.toString() ? `?${params}` : ''}`, {
     method: 'POST',
     headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
     body: JSON.stringify({ name: projectName, target: 'production', files }),
@@ -313,7 +405,7 @@ async function vercelDeploy(accessToken, teamId, projectName, files) {
 async function vercelSetEnvVars(accessToken, teamId, projectIdOrName, vars) {
   const params = new URLSearchParams({ upsert: 'true' });
   if (teamId) params.set('teamId', teamId);
-  const res = await fetch(`https://api.vercel.com/v10/projects/${encodeURIComponent(projectIdOrName)}/env?${params}`, {
+  const res = await fetch(`${API.vercel()}/v10/projects/${encodeURIComponent(projectIdOrName)}/env?${params}`, {
     method: 'POST',
     headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
     body: JSON.stringify(vars.map((v) => ({
@@ -326,7 +418,7 @@ async function vercelSetEnvVars(accessToken, teamId, projectIdOrName, vars) {
 }
 
 async function supabaseListOrganizations(accessToken) {
-  const res = await fetch('https://api.supabase.com/v1/organizations', {
+  const res = await fetch(`${API.supabase()}/v1/organizations`, {
     headers: { Authorization: `Bearer ${accessToken}` },
   });
   const body = await res.json();
@@ -343,8 +435,8 @@ const SUPABASE_PROVISION_TIMEOUT_MS = 3 * 60 * 1000;
  * until it flips to `ACTIVE_HEALTHY` (or gives up after the timeout; the
  * project still exists at that point, it's just not confirmed ready yet).
  */
-async function supabaseCreateProject(accessToken, { name, organizationSlug, dbPass, region = 'us-east-1' }) {
-  const res = await fetch('https://api.supabase.com/v1/projects', {
+async function supabaseCreateProject(accessToken, { name, organizationSlug, dbPass, region = 'us-east-1', pollMs = SUPABASE_PROVISION_POLL_MS }) {
+  const res = await fetch(`${API.supabase()}/v1/projects`, {
     method: 'POST',
     headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
     // Despite older docs listing it as optional, the API now rejects project
@@ -357,8 +449,8 @@ async function supabaseCreateProject(accessToken, { name, organizationSlug, dbPa
   const ref = project.ref;
   const deadline = Date.now() + SUPABASE_PROVISION_TIMEOUT_MS;
   while (project.status !== 'ACTIVE_HEALTHY' && Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, SUPABASE_PROVISION_POLL_MS));
-    const pr = await fetch(`https://api.supabase.com/v1/projects/${ref}`, { headers: { Authorization: `Bearer ${accessToken}` } });
+    await new Promise((r) => setTimeout(r, pollMs));
+    const pr = await fetch(`${API.supabase()}/v1/projects/${ref}`, { headers: { Authorization: `Bearer ${accessToken}` } });
     project = await pr.json();
     if (!pr.ok) throw new Error(project.message || `Supabase project status check failed (HTTP ${pr.status})`);
   }
@@ -369,7 +461,7 @@ async function supabaseCreateProject(accessToken, { name, organizationSlug, dbPa
 }
 
 async function supabaseListProjects(accessToken) {
-  const res = await fetch('https://api.supabase.com/v1/projects', {
+  const res = await fetch(`${API.supabase()}/v1/projects`, {
     headers: { Authorization: `Bearer ${accessToken}` },
   });
   const body = await res.json();
@@ -379,7 +471,7 @@ async function supabaseListProjects(accessToken) {
 
 /** Permanent, irreversible - Supabase does not soft-delete or restore a removed project. */
 async function supabaseDeleteProject(accessToken, ref) {
-  const res = await fetch(`https://api.supabase.com/v1/projects/${ref}`, {
+  const res = await fetch(`${API.supabase()}/v1/projects/${ref}`, {
     method: 'DELETE',
     headers: { Authorization: `Bearer ${accessToken}` },
   });
@@ -390,7 +482,7 @@ async function supabaseDeleteProject(accessToken, ref) {
 
 /** anon/public key + project URL + DB connection string. The connection string is built locally (not fetched) since dbPass was chosen by the caller, not returned by the API. */
 async function supabaseGetProjectKeys(accessToken, ref, dbPass) {
-  const res = await fetch(`https://api.supabase.com/v1/projects/${ref}/api-keys?reveal=true`, {
+  const res = await fetch(`${API.supabase()}/v1/projects/${ref}/api-keys?reveal=true`, {
     headers: { Authorization: `Bearer ${accessToken}` },
   });
   const keys = await res.json();
@@ -407,7 +499,7 @@ async function supabaseGetProjectKeys(accessToken, ref, dbPass) {
 /** Supabase OAuth access tokens expire; the refresh token doesn't (until revoked). */
 async function refreshSupabaseToken(clientId, clientSecret, refreshToken) {
   const basic = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
-  const res = await fetch('https://api.supabase.com/v1/oauth/token', {
+  const res = await fetch(`${API.supabase()}/v1/oauth/token`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/x-www-form-urlencoded', Authorization: `Basic ${basic}` },
     body: new URLSearchParams({ grant_type: 'refresh_token', refresh_token: refreshToken }),
@@ -448,17 +540,17 @@ async function apiCall(base, accessToken, method, apiPath, body, query) {
 }
 
 function supabaseApi(accessToken, method, apiPath, body) {
-  return apiCall('https://api.supabase.com', accessToken, method, apiPath, body);
+  return apiCall(API.supabase(), accessToken, method, apiPath, body);
 }
 
 /** Runs SQL against a project's Postgres through the Management API. */
 function supabaseQuery(accessToken, ref, query) {
-  return apiCall('https://api.supabase.com', accessToken, 'POST', `/v1/projects/${encodeURIComponent(ref)}/database/query`, { query });
+  return apiCall(API.supabase(), accessToken, 'POST', `/v1/projects/${encodeURIComponent(ref)}/database/query`, { query });
 }
 
 /** teamId is appended automatically when the connection was installed to a team. */
 function vercelApi(accessToken, teamId, method, apiPath, body) {
-  return apiCall('https://api.vercel.com', accessToken, method, apiPath, body, { teamId });
+  return apiCall(API.vercel(), accessToken, method, apiPath, body, { teamId });
 }
 
 // GitHub's standard OAuth Apps flow (docs.github.com/apps/oauth-apps) - much
@@ -486,7 +578,7 @@ async function exchangeGithubCode(clientId, clientSecret, code, redirectUri) {
 }
 
 async function getGithubProfile(accessToken) {
-  const res = await fetch('https://api.github.com/user', {
+  const res = await fetch(`${API.github()}/user`, {
     headers: { Authorization: `Bearer ${accessToken}`, Accept: 'application/vnd.github+json' },
   });
   const body = await res.json();
@@ -496,7 +588,7 @@ async function getGithubProfile(accessToken) {
 
 /** Creates a new repo under the connected user's account. Defaults to private - safer for an arbitrary local folder than defaulting public. */
 async function githubCreateRepo(accessToken, name, { private: isPrivate = true } = {}) {
-  const res = await fetch('https://api.github.com/user/repos', {
+  const res = await fetch(`${API.github()}/user/repos`, {
     method: 'POST',
     headers: {
       Authorization: `Bearer ${accessToken}`,
@@ -511,8 +603,38 @@ async function githubCreateRepo(accessToken, name, { private: isPrivate = true }
   return body; // { name, full_name, html_url, clone_url, default_branch, ... }
 }
 
+/**
+ * The token fallback in Connect Apps: the user pastes their own personal
+ * access token (Vercel account token, Supabase access token, GitHub token)
+ * when no OAuth app is configured. One read-only call proves it works and
+ * gives the label shown on the card. The token itself is never logged.
+ */
+async function checkAccessToken(name, token) {
+  const t = String(token || '').trim();
+  if (!t || /\s/.test(t)) throw new Error('That does not look like a token. Paste it again without spaces.');
+  if (name === 'vercel') {
+    const res = await fetch(`${API.vercel()}/v2/user`, { headers: { Authorization: `Bearer ${t}` } });
+    const body = await readJson(res);
+    if (!res.ok) throw new Error(res.status === 403 || res.status === 401 ? 'Vercel did not accept that token. Create a new one at vercel.com/account/settings/tokens.' : `Vercel check failed (HTTP ${res.status}).`);
+    return { accessToken: t, userName: body.user?.username || body.user?.email || '' };
+  }
+  if (name === 'supabase') {
+    const res = await fetch(`${API.supabase()}/v1/organizations`, { headers: { Authorization: `Bearer ${t}` } });
+    const body = await readJson(res);
+    if (!res.ok) throw new Error(res.status === 401 || res.status === 403 ? 'Supabase did not accept that token. Create a new one at supabase.com/dashboard/account/tokens.' : `Supabase check failed (HTTP ${res.status}).`);
+    return { accessToken: t, refreshToken: '', expiresAt: 0, email: Array.isArray(body) && body[0] ? body[0].name : '' };
+  }
+  if (name === 'github') {
+    const userName = await getGithubProfile(t).catch(() => { throw new Error('GitHub did not accept that token. Create one with the "repo" scope at github.com/settings/tokens.'); });
+    return { accessToken: t, userName };
+  }
+  throw new Error(`${name} has no token sign-in.`);
+}
+
 module.exports = {
-  buildGmailAuthUrl, exchangeGmailCode, refreshGmailToken, getGmailProfile, gmailSend, gmailSearch,
+  API, apiCall, checkAccessToken,
+  buildGmailAuthUrl, exchangeGmailCode, refreshGmailToken, getGmailProfile, gmailSend, gmailSearch, gmailCreateDraft, gmailError, rawEmail,
+  calendarListEvents, calendarInsertEvent, calendarError, GOOGLE_SCOPE,
   buildSlackAuthUrl, exchangeSlackCode, slackPostMessage, slackListChannels, slackJoinChannel,
   buildVercelAuthUrl, exchangeVercelCode, getVercelProfile, vercelDeploy, vercelSetEnvVars,
   buildSupabaseAuthUrl, exchangeSupabaseCode, refreshSupabaseToken, supabaseListOrganizations, supabaseCreateProject, supabaseGetProjectKeys,

package/lib/permissions.js

@@ -1,109 +1,109 @@
-/**
- * Standing permission rules, set once in a file instead of clicked per chat.
- *
- *   ~/.codeply/permissions.json            (every project)
- *   <project>/.codeply/permissions.json    (this project, checked first)
- *
- *   {
- *     "deny":  ["run:git push*", "run:rm*", "write_file:*.env", "supabase_delete_project"],
- *     "allow": ["run:npm test", "run:npm run *", "run:git status", "edit_file:src/**"]
- *   }
- *
- * A rule is "<tool>" or "<tool>:<pattern>". For run the pattern matches the
- * command's name (npm run dev, git checkout) and the full command line; for
- * file tools it matches the path relative to the project. * matches within a
- * path segment, ** across them, and a trailing " *" also matches the bare
- * command. Deny beats allow; project rules beat global ones; anything no rule
- * mentions is asked as usual. Evaluation is the same idea as opencode's
- * permission/ rulesets.
- */
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-function readRules(file) {
-  try {
-    const j = JSON.parse(fs.readFileSync(file, 'utf8'));
-    const list = (k) => (Array.isArray(j[k]) ? j[k].map(String).filter(Boolean) : []);
-    return { allow: list('allow'), deny: list('deny') };
-  } catch { return { allow: [], deny: [] }; }
-}
-
-function wildcard(pattern) {
-  let re = '';
-  for (let i = 0; i < pattern.length; i++) {
-    const c = pattern[i];
-    if (c === '*' && pattern[i + 1] === '*') { re += '.*'; i++; }
-    else if (c === '*') re += '[^/]*';
-    else if (c === '?') re += '.';
-    else re += c.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-  }
-  // "npm run *" should also cover plain "npm run".
-  re = re.replace(/ \[\^\/\]\*$/, '(?: .*)?').replace(/ \.\*$/, '(?: .*)?');
-  return new RegExp(`^${re}$`, process.platform === 'win32' ? 'i' : '');
-}
-
-/** Strings a request can be matched against for its tool. */
-function subjects(req, cwd) {
-  if (req.tool === 'run') {
-    const cmd = String(req.detail || '').trim();
-    // Commands match by name AND as full text, so "run:npm run *" and
-    // "run:git push*" both work.
-    return { cmd, names: Array.isArray(req.patterns) ? req.patterns : [] };
-  }
-  if (req.path) {
-    const abs = path.isAbsolute(req.path) ? req.path : path.resolve(cwd || '.', req.path);
-    const rel = path.relative(cwd || '.', abs).replace(/\\/g, '/');
-    return { path: rel.startsWith('..') ? abs.replace(/\\/g, '/') : rel };
-  }
-  return {};
-}
-
-function ruleMatches(rule, req, subj) {
-  const i = rule.indexOf(':');
-  const tool = (i === -1 ? rule : rule.slice(0, i)).trim();
-  const pattern = i === -1 ? null : rule.slice(i + 1).trim();
-  if (tool !== req.tool && tool !== '*') return false;
-  if (!pattern || pattern === '*') return true;
-  const re = wildcard(pattern);
-  if (req.tool === 'run') {
-    if (re.test(subj.cmd)) return true;
-    // For allow on a compound command every part must be covered (checked by
-    // the caller); here a single name matching is enough to count.
-    return subj.names.some((n) => re.test(n));
-  }
-  return subj.path ? re.test(subj.path) : false;
-}
-
-/**
- * @param {object} req  the approval request ({tool, detail, patterns, path, danger})
- * @returns {{decision: 'allow'|'deny'|null, rule?: string, file?: string}}
- */
-function decide(req, cwd) {
-  const files = [cwd && path.join(cwd, '.codeply', 'permissions.json'), path.join(os.homedir(), '.codeply', 'permissions.json')].filter(Boolean);
-  const sets = files.map((f) => ({ file: f, ...readRules(f) }));
-  const subj = subjects(req, cwd);
-  for (const s of sets) {
-    const hit = s.deny.find((r) => ruleMatches(r, req, subj));
-    if (hit) return { decision: 'deny', rule: hit, file: s.file };
-  }
-  // Risky-looking commands (rm -rf, format, curl | sh...) always ask.
-  if (req.danger) return { decision: null };
-  for (const s of sets) {
-    if (req.tool === 'run') {
-      // Allow is judged per command, never on the whole line: "npm run *"
-      // must not let "npm run build && npm install" through. A line that
-      // can't be split into named commands (subshells, redirects) is never
-      // auto-allowed.
-      if (!subj.names.length) continue;
-      const parts = subj.names.length === 1 ? [{ cmd: subj.cmd, names: subj.names }] : subj.names.map((n) => ({ cmd: n, names: [n] }));
-      if (parts.every((p) => s.allow.some((r) => ruleMatches(r, req, p)))) return { decision: 'allow', rule: 'allow rules', file: s.file };
-      continue;
-    }
-    const hit = s.allow.find((r) => ruleMatches(r, req, subj));
-    if (hit) return { decision: 'allow', rule: hit, file: s.file };
-  }
-  return { decision: null };
-}
-
-module.exports = { decide, wildcard };
+/**
+ * Standing permission rules, set once in a file instead of clicked per chat.
+ *
+ *   ~/.codeply/permissions.json            (every project)
+ *   <project>/.codeply/permissions.json    (this project, checked first)
+ *
+ *   {
+ *     "deny":  ["run:git push*", "run:rm*", "write_file:*.env", "supabase_delete_project"],
+ *     "allow": ["run:npm test", "run:npm run *", "run:git status", "edit_file:src/**"]
+ *   }
+ *
+ * A rule is "<tool>" or "<tool>:<pattern>". For run the pattern matches the
+ * command's name (npm run dev, git checkout) and the full command line; for
+ * file tools it matches the path relative to the project. * matches within a
+ * path segment, ** across them, and a trailing " *" also matches the bare
+ * command. Deny beats allow; project rules beat global ones; anything no rule
+ * mentions is asked as usual. Evaluation is the same idea as opencode's
+ * permission/ rulesets.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function readRules(file) {
+  try {
+    const j = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const list = (k) => (Array.isArray(j[k]) ? j[k].map(String).filter(Boolean) : []);
+    return { allow: list('allow'), deny: list('deny') };
+  } catch { return { allow: [], deny: [] }; }
+}
+
+function wildcard(pattern) {
+  let re = '';
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === '*' && pattern[i + 1] === '*') { re += '.*'; i++; }
+    else if (c === '*') re += '[^/]*';
+    else if (c === '?') re += '.';
+    else re += c.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+  }
+  // "npm run *" should also cover plain "npm run".
+  re = re.replace(/ \[\^\/\]\*$/, '(?: .*)?').replace(/ \.\*$/, '(?: .*)?');
+  return new RegExp(`^${re}$`, process.platform === 'win32' ? 'i' : '');
+}
+
+/** Strings a request can be matched against for its tool. */
+function subjects(req, cwd) {
+  if (req.tool === 'run') {
+    const cmd = String(req.detail || '').trim();
+    // Commands match by name AND as full text, so "run:npm run *" and
+    // "run:git push*" both work.
+    return { cmd, names: Array.isArray(req.patterns) ? req.patterns : [] };
+  }
+  if (req.path) {
+    const abs = path.isAbsolute(req.path) ? req.path : path.resolve(cwd || '.', req.path);
+    const rel = path.relative(cwd || '.', abs).replace(/\\/g, '/');
+    return { path: rel.startsWith('..') ? abs.replace(/\\/g, '/') : rel };
+  }
+  return {};
+}
+
+function ruleMatches(rule, req, subj) {
+  const i = rule.indexOf(':');
+  const tool = (i === -1 ? rule : rule.slice(0, i)).trim();
+  const pattern = i === -1 ? null : rule.slice(i + 1).trim();
+  if (tool !== req.tool && tool !== '*') return false;
+  if (!pattern || pattern === '*') return true;
+  const re = wildcard(pattern);
+  if (req.tool === 'run') {
+    if (re.test(subj.cmd)) return true;
+    // For allow on a compound command every part must be covered (checked by
+    // the caller); here a single name matching is enough to count.
+    return subj.names.some((n) => re.test(n));
+  }
+  return subj.path ? re.test(subj.path) : false;
+}
+
+/**
+ * @param {object} req  the approval request ({tool, detail, patterns, path, danger})
+ * @returns {{decision: 'allow'|'deny'|null, rule?: string, file?: string}}
+ */
+function decide(req, cwd) {
+  const files = [cwd && path.join(cwd, '.codeply', 'permissions.json'), path.join(os.homedir(), '.codeply', 'permissions.json')].filter(Boolean);
+  const sets = files.map((f) => ({ file: f, ...readRules(f) }));
+  const subj = subjects(req, cwd);
+  for (const s of sets) {
+    const hit = s.deny.find((r) => ruleMatches(r, req, subj));
+    if (hit) return { decision: 'deny', rule: hit, file: s.file };
+  }
+  // Risky-looking commands (rm -rf, format, curl | sh...) always ask.
+  if (req.danger) return { decision: null };
+  for (const s of sets) {
+    if (req.tool === 'run') {
+      // Allow is judged per command, never on the whole line: "npm run *"
+      // must not let "npm run build && npm install" through. A line that
+      // can't be split into named commands (subshells, redirects) is never
+      // auto-allowed.
+      if (!subj.names.length) continue;
+      const parts = subj.names.length === 1 ? [{ cmd: subj.cmd, names: subj.names }] : subj.names.map((n) => ({ cmd: n, names: [n] }));
+      if (parts.every((p) => s.allow.some((r) => ruleMatches(r, req, p)))) return { decision: 'allow', rule: 'allow rules', file: s.file };
+      continue;
+    }
+    const hit = s.allow.find((r) => ruleMatches(r, req, subj));
+    if (hit) return { decision: 'allow', rule: hit, file: s.file };
+  }
+  return { decision: null };
+}
+
+module.exports = { decide, wildcard };