codeply-cli 0.5.5 → 0.6.0

package/lib/oauth-connectors.js

@@ -27,14 +27,18 @@ const GMAIL_SCOPES = ['https://www.googleapis.com/auth/gmail.readonly', 'https:/
 // 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.
-const SLACK_SCOPES = 'chat:write,channels:read,channels:history,channels:join';
+// chat:write.customize lets a Crew bot post under its own name; im:history,
+// im:read and app_mentions:read bring the user's messages to their bots
+// (slack-events on Codeply's server).
+const SLACK_SCOPES = 'chat:write,channels:read,channels:history,channels:join,chat:write.customize,im:history,im:read,app_mentions:read,users:read';
 // Separate from the bot scopes above - Slack issues bot and user tokens
 // through entirely different mechanisms in the same OAuth exchange. `scope`
 // requests the bot token (posts as "Codeply Craft APP"); `user_scope`
 // requests a second, independent token that posts as the actual signed-in
 // user. Both come back in one authorize round-trip, but they're genuinely
 // two different tokens with two different scope sets.
-const SLACK_USER_SCOPES = 'chat:write';
+// im:history: direct messages to the user reach their bots (drafts only; the user sends their own replies).
+const SLACK_USER_SCOPES = 'chat:write,im:history';
 
 function buildGmailAuthUrl(clientId, redirectUri) {
   const params = new URLSearchParams({
@@ -115,6 +119,8 @@ function gmailError(data, status, what, scopeHint) {
   else if (status === 400) hint = ' Reconnecting Gmail in Connect Apps usually fixes this.';
   const e = new Error(`${what} failed (HTTP ${status}${reason ? `, ${reason}` : ''}): ${detail || 'no details from Google'}.${hint}`);
   e.status = status;
+  // Switched off on Codeply's side: only Codeply can fix it, so the user is never sent to set it up.
+  if (status === 403 && /accessNotConfigured|SERVICE_DISABLED|has not been used/i.test(detail + reason)) e.serviceSide = true;
   return e;
 }
 
@@ -131,20 +137,20 @@ function base64UrlEncode(str) {
  * 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 }) {
+function rawEmail({ to, cc, 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)}`,
+    to ? `To: ${oneLine(to)}` : '', cc ? `Cc: ${oneLine(cc)}` : '', `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 = rawEmail({ to, subject, body });
+async function gmailSend(accessToken, { to, cc, subject, body }) {
+  const raw = rawEmail({ to, cc, 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' },
@@ -156,8 +162,8 @@ async function gmailSend(accessToken, { to, subject, body }) {
 }
 
 /** 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 }) };
+async function gmailCreateDraft(accessToken, { to, cc, subject, body, threadId, inReplyTo, references }) {
+  const message = { raw: rawEmail({ to, cc, 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',
@@ -189,6 +195,7 @@ function calendarError(data, status, what) {
   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;
+  if (status === 403 && /accessNotConfigured|SERVICE_DISABLED|has not been used|is disabled/i.test(text)) e.serviceSide = true;
   return e;
 }
 
@@ -203,9 +210,10 @@ async function calendarListEvents(accessToken, { timeMin, timeMax, maxResults =
   return data.items || [];
 }
 
-/** Creates an event on the primary calendar. `event` is a Calendar API event resource. */
+/** Creates an event on the primary calendar. `event` is a Calendar API event resource. Guests get an invite. */
 async function calendarInsertEvent(accessToken, event) {
-  const res = await fetch(CALENDAR_EVENTS_URL, {
+  const invite = Array.isArray(event.attendees) && event.attendees.length ? '?sendUpdates=all' : '';
+  const res = await fetch(`${CALENDAR_EVENTS_URL}${invite}`, {
     method: 'POST',
     headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
     body: JSON.stringify(event),
@@ -215,6 +223,40 @@ async function calendarInsertEvent(accessToken, event) {
   return data; // { id, htmlLink, ... }
 }
 
+/** Moves, renames or changes one event (a partial resource). Guests hear about it. */
+async function calendarPatchEvent(accessToken, id, patch) {
+  const res = await fetch(`${CALENDAR_EVENTS_URL}/${encodeURIComponent(id)}?sendUpdates=all`, {
+    method: 'PATCH',
+    headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(patch),
+  });
+  const data = await readJson(res);
+  if (!res.ok) throw calendarError(data, res.status, 'Calendar update');
+  return data;
+}
+
+/** Cancels one event. Guests are told. */
+async function calendarDeleteEvent(accessToken, id) {
+  const res = await fetch(`${CALENDAR_EVENTS_URL}/${encodeURIComponent(id)}?sendUpdates=all`, { method: 'DELETE', headers: { Authorization: `Bearer ${accessToken}` } });
+  if (!res.ok && res.status !== 410) throw calendarError(await readJson(res), res.status, 'Calendar cancel');
+  return { ok: true };
+}
+
+/** One whole email: headers and the plain-text body (HTML turned into text). */
+async function gmailGetMessage(accessToken, id) {
+  const res = await fetch(`https://www.googleapis.com/gmail/v1/users/me/messages/${encodeURIComponent(id)}?format=full`, { headers: { Authorization: `Bearer ${accessToken}` } });
+  const msg = await readJson(res);
+  if (!res.ok) throw gmailError(msg, res.status, 'Gmail read');
+  const header = (name) => (msg.payload?.headers || []).find((h) => h.name.toLowerCase() === name.toLowerCase())?.value || '';
+  const parts = [];
+  const walk = (p) => { if (!p) return; if (p.body?.data && /^text\/(plain|html)/.test(p.mimeType || 'text/plain')) parts.push({ type: p.mimeType || 'text/plain', text: Buffer.from(p.body.data, 'base64url').toString('utf8') }); (p.parts || []).forEach(walk); };
+  walk(msg.payload);
+  const plain = parts.find((p) => p.type.startsWith('text/plain'));
+  const html = parts.find((p) => p.type.startsWith('text/html'));
+  const body = plain ? plain.text : html ? html.text.replace(/<style[\s\S]*?<\/style>|<script[\s\S]*?<\/script>/gi, '').replace(/<br\s*\/?>|<\/p>|<\/div>/gi, '\n').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&') : (msg.snippet || '');
+  return { id: msg.id, threadId: msg.threadId, from: header('From'), to: header('To'), cc: header('Cc'), subject: header('Subject'), date: header('Date'), body };
+}
+
 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.
@@ -273,7 +315,7 @@ async function slackJoinChannel(accessToken, channelId) {
   if (!body.ok && body.error !== 'already_in_channel') throw new Error(body.error || 'Could not join the channel');
 }
 
-async function slackPostMessage(accessToken, { channel, text }, { isUserToken = false } = {}) {
+async function slackPostMessage(accessToken, { channel, text, threadTs }, { isUserToken = false, asName = '' } = {}) {
   // A bot token's chat:write only covers channels the app has actually
   // joined - not "any public channel" the way a human member can post to.
   // Auto-joining first (public channels only; that's all resolveSlackChannel
@@ -287,16 +329,29 @@ async function slackPostMessage(accessToken, { channel, text }, { isUserToken =
   // either already belongs to the channel or doesn't - conversations.join
   // isn't the right operation for a user identity the way it is for a bot,
   // so this is skipped entirely on that path.
-  if (!isUserToken) await slackJoinChannel(accessToken, channel);
-
-  const res = await fetch('https://slack.com/api/chat.postMessage', {
-    method: 'POST',
-    headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
-    body: JSON.stringify({ channel, text }),
-  });
-  const body = await res.json();
+  // A direct message (D...) is not something to join.
+  if (!isUserToken && !/^D/.test(String(channel))) await slackJoinChannel(accessToken, channel);
+
+  // asName: a Crew bot posting as itself (chat:write.customize). A workspace
+  // connected before that scope existed refuses the name: then it posts with
+  // the bot's name in the text instead, still never as the user.
+  const thread = threadTs ? { thread_ts: threadTs } : {};
+  const post = async (extra) => {
+    const res = await fetch('https://slack.com/api/chat.postMessage', {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ channel, text, ...thread, ...extra }),
+    });
+    return res.json();
+  };
+  let named = !!asName && !isUserToken;
+  let body = await post(named ? { username: String(asName).slice(0, 80) } : {});
+  if (!body.ok && named && /missing_scope|not_allowed|invalid_arguments/.test(String(body.error))) {
+    named = false;
+    body = await post({ text: `*${String(asName).slice(0, 80)}:* ${text}` });
+  }
   if (!body.ok) throw new Error(body.error || 'Slack message failed to send');
-  return body;
+  return { ...body, named };
 }
 
 async function slackListChannels(accessToken) {
@@ -634,7 +689,7 @@ async function checkAccessToken(name, token) {
 module.exports = {
   API, apiCall, checkAccessToken,
   buildGmailAuthUrl, exchangeGmailCode, refreshGmailToken, getGmailProfile, gmailSend, gmailSearch, gmailCreateDraft, gmailError, rawEmail,
-  calendarListEvents, calendarInsertEvent, calendarError, GOOGLE_SCOPE,
+  calendarListEvents, calendarInsertEvent, calendarPatchEvent, calendarDeleteEvent, gmailGetMessage, 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 };