atris 3.53.0 → 3.56.0

package/commands/integrations.js

@@ -2,8 +2,14 @@
  * Integration commands for Atris CLI
  *
  * Usage:
- *   atris gmail inbox       - List recent emails
- *   atris gmail read <id>   - Read specific email
+ *   atris gmail inbox [--account <id>]       - List recent emails for a mailbox
+ *   atris gmail read <id> [--account <id>]   - Read specific email
+ *   atris gmail archive <id> [...] [--account <id>] - Archive messages
+ *   atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>] - Send an email
+ *   atris gmail voice [account] [--clear]    - Edit an account's writing voice
+ *   atris gmail connect [name]              - Connect or reconnect a Gmail account
+ *   atris gmail accounts                     - List connected Gmail accounts and the active account
+ *   atris gmail use [<account_id|name>]      - Choose or set the active Gmail account
  *   atris calendar today    - Show today's events
  *   atris calendar yesterday - Show yesterday's events
  *   atris calendar week     - Show this week's events
@@ -25,9 +31,116 @@ const {
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const readline = require('readline');
 const { spawnSync } = require('child_process');
 
 const CALENDAR_CACHE_PATH = path.join(os.homedir(), '.atris', 'calendar-events-cache.json');
+const GMAIL_CONNECT_POLL_MS = 3000;
+const GMAIL_CONNECT_TIMEOUT_MS = 3 * 60 * 1000;
+const GMAIL_SEND_USAGE = 'usage: atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>]';
+const GMAIL_VOICE_USAGE = 'usage: atris gmail voice [account] [--clear]';
+
+function gmailAccountStatePath() {
+  return process.env.ATRIS_GMAIL_ACCOUNT_FILE
+    || path.join(os.homedir(), '.atris', 'gmail-account.json');
+}
+
+function readGmailStickyAccount() {
+  try {
+    const data = JSON.parse(fs.readFileSync(gmailAccountStatePath(), 'utf8'));
+    const id = String(data.account_id || '').trim();
+    return id || null;
+  } catch {
+    return null;
+  }
+}
+
+function writeGmailStickyAccount(accountId) {
+  const filePath = gmailAccountStatePath();
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify({ account_id: accountId }, null, 2)}\n`, 'utf8');
+}
+
+function resolveGmailAccountId(explicitId) {
+  const trimmed = String(explicitId || '').trim();
+  if (trimmed) return trimmed;
+  const sticky = readGmailStickyAccount();
+  if (sticky) return sticky;
+  return 'default';
+}
+
+function gmailAccountIdentity(account = {}) {
+  const id = String(account.account_id || account.id || 'default').trim() || 'default';
+  const email = String(account.email_address || account.email || '').trim().toLowerCase();
+  const name = String(account.display_name || account.name || id).trim().toLowerCase() || id.toLowerCase();
+  return { id, email, name };
+}
+
+function sortGmailAccounts(accounts) {
+  return [...accounts].sort((left, right) => {
+    const leftIdentity = gmailAccountIdentity(left);
+    const rightIdentity = gmailAccountIdentity(right);
+    const leftDefault = leftIdentity.id.toLowerCase() === 'default';
+    const rightDefault = rightIdentity.id.toLowerCase() === 'default';
+    if (leftDefault !== rightDefault) return leftDefault ? -1 : 1;
+    return leftIdentity.name.localeCompare(rightIdentity.name)
+      || leftIdentity.id.localeCompare(rightIdentity.id);
+  });
+}
+
+function formatGmailAccountRows(accounts, activeId = null) {
+  const rows = sortGmailAccounts(accounts).map((account) => {
+    const identity = gmailAccountIdentity(account);
+    return { ...identity, emailLabel: identity.email || 'email pending' };
+  });
+  const nameWidth = Math.max(...rows.map((row) => row.name.length));
+  const emailWidth = Math.max(...rows.map((row) => row.emailLabel.length));
+  const active = String(activeId || '').toLowerCase();
+  return rows.map((row) => {
+    const marker = row.id.toLowerCase() === active ? '  (active)' : '';
+    return `${row.name.padEnd(nameWidth)}  ${row.emailLabel.padEnd(emailWidth)}${marker}`.trimEnd();
+  });
+}
+
+async function fetchGmailAccounts(token, options = {}) {
+  const result = await apiRequestJson('/integrations/gmail/accounts', {
+    method: 'GET',
+    token,
+  });
+  if (!result.ok) {
+    if (options.quiet) return [];
+    console.error(`Error: ${result.error || 'Failed to fetch accounts'}`);
+    process.exit(1);
+  }
+  const accounts = result.data?.accounts || result.data || [];
+  return Array.isArray(accounts) ? accounts : [];
+}
+
+function findGmailAccount(accounts, accountId) {
+  const wanted = String(accountId || '').trim().toLowerCase();
+  return accounts.find((account) => gmailAccountIdentity(account).id.toLowerCase() === wanted) || null;
+}
+
+function findGmailAccountForUse(accounts, selector) {
+  const wanted = String(selector || '').trim().toLowerCase();
+  return findGmailAccount(accounts, wanted)
+    || accounts.find((account) => gmailAccountIdentity(account).name === wanted)
+    || null;
+}
+
+async function promptForGmailAccount(deps = {}) {
+  if (deps.prompt) return deps.prompt('choose account: ');
+  const rl = readline.createInterface({
+    input: deps.input || process.stdin,
+    output: deps.output || process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question('choose account: ', (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
 
 async function getAuth() {
   const ensured = await ensureValidCredentials(apiRequestJson);
@@ -51,13 +164,54 @@ async function getAuthToken() {
 // GMAIL
 // ============================================================================
 
+function extractGmailMailboxAccount(args = []) {
+  const out = [];
+  let mailboxAccountId = null;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--account' && args[i + 1] && !String(args[i + 1]).startsWith('-')) {
+      mailboxAccountId = args[i + 1];
+      i += 1;
+      continue;
+    }
+    out.push(arg);
+  }
+  return { args: out, mailboxAccountId };
+}
+
+function parseGmailArgs(args = []) {
+  const options = { accountId: null };
+  const positional = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--account') {
+      options.accountId = String(args[i + 1] || '').trim();
+      if (!options.accountId) {
+        console.error('Usage: --account requires an account id');
+        process.exit(1);
+      }
+      i += 1;
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { ...options, positional };
+}
+
 async function gmailInbox(options = {}) {
   const { token, email } = await getAuth();
   const limit = options.limit || 10;
+  const accountId = resolveGmailAccountId(options.accountId);
+  const accounts = await fetchGmailAccounts(token, { quiet: true });
+  const account = findGmailAccount(accounts, accountId);
+  const mailboxEmail = account ? gmailAccountIdentity(account).email : '';
 
+  if (mailboxEmail) console.log(`inbox for ${mailboxEmail} (${accountId.toLowerCase()})`);
   console.log('📬 Fetching inbox...\n');
 
-  const result = await apiRequestJson(`/integrations/gmail/messages?max_results=${limit}`, {
+  const path = `/integrations/gmail/messages?max_results=${limit}&account_id=${encodeURIComponent(accountId)}`;
+
+  const result = await apiRequestJson(path, {
     method: 'GET',
     token,
   });
@@ -97,17 +251,20 @@ async function gmailInbox(options = {}) {
   }
 }
 
-async function gmailRead(messageId) {
+async function gmailRead(messageId, options = {}) {
   if (!messageId) {
-    console.error('Usage: atris gmail read <message_id>');
+    console.error('Usage: atris gmail read <message_id> [--account <id>]');
     process.exit(1);
   }
 
   const token = await getAuthToken();
+  const accountId = resolveGmailAccountId(options.accountId);
 
   console.log('📧 Fetching message...\n');
 
-  const result = await apiRequestJson(`/integrations/gmail/messages/${messageId}`, {
+  const path = `/integrations/gmail/messages/${messageId}?account_id=${encodeURIComponent(accountId)}`;
+
+  const result = await apiRequestJson(path, {
     method: 'GET',
     token,
   });
@@ -129,21 +286,24 @@ async function gmailRead(messageId) {
   console.log(msg.body || msg.snippet || '(no body)');
 }
 
-async function gmailArchive(messageIds) {
+async function gmailArchive(messageIds, options = {}) {
   const ids = (messageIds || []).map(id => String(id || '').trim()).filter(Boolean);
   if (!ids.length) {
-    console.error('Usage: atris gmail archive <message_id> [<message_id> ...]');
+    console.error('Usage: atris gmail archive <message_id> [<message_id> ...] [--account <id>]');
     process.exit(1);
   }
 
   const token = await getAuthToken();
+  const accountId = resolveGmailAccountId(options.accountId);
 
   console.log(`Archiving ${ids.length} message${ids.length === 1 ? '' : 's'}...`);
 
+  const body = { message_ids: ids, account_id: accountId };
+
   const result = await apiRequestJson('/integrations/gmail/messages/batch-archive', {
     method: 'POST',
     token,
-    body: { message_ids: ids },
+    body,
   });
 
   if (!result.ok) {
@@ -155,23 +315,330 @@ async function gmailArchive(messageIds) {
   console.log(`Archived ${archived} message${archived === 1 ? '' : 's'}. They stay searchable in All Mail.`);
 }
 
+function parseGmailSendArgs(args = []) {
+  let accountId = null;
+  let bodyFile = null;
+  const positional = [];
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--account' || arg === '--body-file') {
+      const value = String(args[i + 1] || '').trim();
+      if (!value || value.startsWith('--')) {
+        console.error(GMAIL_SEND_USAGE);
+        process.exit(2);
+      }
+      if (arg === '--account') accountId = value;
+      else bodyFile = value;
+      i += 1;
+      continue;
+    }
+    positional.push(arg);
+  }
+
+  const [to, subject, ...bodyParts] = positional;
+  if (!String(to || '').trim()
+    || !String(subject || '').trim()
+    || (bodyFile ? bodyParts.length > 0 : bodyParts.length === 0)) {
+    console.error(GMAIL_SEND_USAGE);
+    process.exit(2);
+  }
+
+  let body = bodyParts.join(' ');
+  if (bodyFile) {
+    try {
+      body = fs.readFileSync(bodyFile, 'utf8');
+    } catch (error) {
+      console.error(`could not read body file "${bodyFile}": ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  return { to, subject, body, accountId };
+}
+
+async function gmailSend(to, subject, body, options = {}) {
+  const token = await getAuthToken();
+  const accountId = resolveGmailAccountId(options.accountId);
+  const accounts = await fetchGmailAccounts(token);
+  const account = findGmailAccount(accounts, accountId);
+
+  if (!account) {
+    console.error(`gmail account "${accountId}" is not connected.`);
+    process.exit(1);
+  }
+
+  const result = await apiRequestJson('/integrations/gmail/send', {
+    method: 'POST',
+    token,
+    body: { to, subject, body, account_id: accountId },
+  });
+
+  if (!result.ok) {
+    console.error(`could not send gmail message: ${result.error || 'request failed'}`);
+    process.exit(1);
+  }
+
+  const { email, id } = gmailAccountIdentity(account);
+  console.log(`sent to ${to} from ${email || id}`);
+}
+
+function parseGmailVoiceArgs(args = []) {
+  let clear = false;
+  const positional = [];
+  for (const arg of args) {
+    if (arg === '--clear') clear = true;
+    else positional.push(arg);
+  }
+  if (positional.length > 1 || positional.some((arg) => String(arg).startsWith('--'))) {
+    console.error(GMAIL_VOICE_USAGE);
+    process.exit(2);
+  }
+  return { accountId: positional[0] || null, clear };
+}
+
+function editGmailVoice(currentVoice, deps = {}) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-gmail-voice-'));
+  const voicePath = path.join(tempDir, 'voice.md');
+  let editedVoice;
+  let editorError = null;
+
+  try {
+    fs.writeFileSync(voicePath, currentVoice, 'utf8');
+    const editor = deps.editor || process.env.EDITOR || 'vi';
+    const shell = deps.shell || process.env.SHELL || '/bin/sh';
+    const run = deps.spawnSync || spawnSync;
+    const result = run(shell, ['-c', 'exec $EDITOR "$1"', 'atris-gmail-voice', voicePath], {
+      stdio: 'inherit',
+      env: { ...process.env, EDITOR: editor },
+    });
+    if (result.error || result.status !== 0) {
+      editorError = result.error?.message || `editor exited with status ${result.status}`;
+    } else {
+      editedVoice = fs.readFileSync(voicePath, 'utf8');
+    }
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+
+  if (editorError) {
+    console.error(`could not edit gmail voice: ${editorError}`);
+    process.exit(1);
+  }
+  return editedVoice;
+}
+
+async function gmailVoice(accountId, options = {}) {
+  const token = await getAuthToken();
+  const resolvedAccountId = resolveGmailAccountId(accountId);
+  const accounts = await fetchGmailAccounts(token);
+  const account = findGmailAccount(accounts, resolvedAccountId);
+
+  if (!account) {
+    console.error(`gmail account "${resolvedAccountId}" is not connected.`);
+    process.exit(1);
+  }
+
+  let voiceMd = '';
+  if (!options.clear) {
+    const stdinIsTTY = options.stdinIsTTY === undefined
+      ? Boolean(process.stdin.isTTY)
+      : options.stdinIsTTY;
+    voiceMd = stdinIsTTY
+      ? editGmailVoice(String(account.voice_md || ''), options)
+      : String((options.readStdin || (() => fs.readFileSync(0, 'utf8')))());
+  }
+
+  const { id, name } = gmailAccountIdentity(account);
+  const result = await apiRequestJson(`/integrations/gmail/accounts/${encodeURIComponent(id)}`, {
+    method: 'PATCH',
+    token,
+    body: { voice_md: voiceMd },
+  });
+
+  if (!result.ok) {
+    console.error(`could not ${options.clear ? 'clear' : 'save'} gmail voice: ${result.error || 'request failed'}`);
+    process.exit(1);
+  }
+
+  console.log(`voice ${options.clear ? 'cleared' : 'saved'} for ${name}`);
+}
+
+function openGmailAuthUrl(authUrl, deps = {}) {
+  const run = deps.spawnSync || spawnSync;
+  const platform = deps.platform || process.platform;
+  const command = platform === 'darwin' ? 'open' : 'xdg-open';
+  const opened = run(command, [authUrl], { stdio: 'ignore' });
+  return !opened.error && opened.status === 0;
+}
+
+async function gmailConnect(accountName, deps = {}) {
+  const accountId = String(accountName || 'default').trim();
+  if (!/^[a-z0-9-]{1,32}$/.test(accountId)) {
+    console.error('invalid gmail account name. use 1 to 32 lowercase letters, numbers, or hyphens.');
+    process.exit(1);
+  }
+
+  const token = await getAuthToken();
+  const result = await apiRequestJson('/integrations/gmail/start', {
+    method: 'POST',
+    token,
+    body: { account_id: accountId },
+  });
+
+  if (!result.ok) {
+    const detail = String(result.error || 'request failed').toLowerCase();
+    console.error(`could not start gmail connection: ${detail}`);
+    process.exit(1);
+  }
+
+  const authUrl = String(result.data?.auth_url || result.data?.url || '').trim();
+  if (!authUrl) {
+    console.error('could not start gmail connection: the server did not return an auth url.');
+    process.exit(1);
+  }
+
+  const openAuthUrl = deps.openAuthUrl || openGmailAuthUrl;
+  if (!openAuthUrl(authUrl, deps)) {
+    console.log(`open this url in your browser: ${authUrl}`);
+  }
+
+  console.log(`waiting for gmail account ${accountId}...`);
+
+  const pollIntervalMs = deps.pollIntervalMs ?? GMAIL_CONNECT_POLL_MS;
+  const timeoutMs = deps.timeoutMs ?? GMAIL_CONNECT_TIMEOUT_MS;
+  const sleep = deps.sleep || ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+  const maxPolls = Math.max(1, Math.ceil(timeoutMs / pollIntervalMs));
+
+  for (let poll = 0; poll < maxPolls; poll += 1) {
+    await sleep(pollIntervalMs);
+    const accountsResult = await apiRequestJson('/integrations/gmail/accounts', {
+      method: 'GET',
+      token,
+    });
+    const accounts = accountsResult.ok
+      ? (accountsResult.data?.accounts || accountsResult.data || [])
+      : [];
+    const match = Array.isArray(accounts) ? findGmailAccount(accounts, accountId) : null;
+    const email = match ? gmailAccountIdentity(match).email.trim() : '';
+    if (email && email !== 'unknown') {
+      console.log(`connected ${email} as ${accountId}`);
+      return;
+    }
+  }
+
+  console.error(`connection timed out. finish in your browser: ${authUrl}`);
+  console.error(`or connect from settings: https://atris.ai/dashboard/settings?connect=gmail&account=${accountId}`);
+  process.exit(1);
+}
+
+async function gmailAccounts() {
+  const token = await getAuthToken();
+  const accounts = await fetchGmailAccounts(token);
+  const activeId = resolveGmailAccountId(null);
+
+  if (!accounts.length) {
+    console.log('no connected accounts.');
+    return;
+  }
+
+  for (const line of formatGmailAccountRows(accounts, activeId)) console.log(line);
+}
+
+async function gmailUse(accountId, deps = {}) {
+  const token = await getAuthToken();
+  const accounts = await fetchGmailAccounts(token);
+  let selector = String(accountId || '').trim();
+
+  if (!selector) {
+    if (!accounts.length) {
+      console.log('no connected accounts.');
+      return;
+    }
+    if (accounts.length === 1) {
+      const { name, email } = gmailAccountIdentity(accounts[0]);
+      console.log(`${name} (${email || 'email pending'}) is already the only gmail account.`);
+      return;
+    }
+
+    const sortedAccounts = sortGmailAccounts(accounts);
+    const activeId = resolveGmailAccountId(null);
+    const rows = formatGmailAccountRows(sortedAccounts, activeId);
+    rows.forEach((line, index) => console.log(`${index + 1}. ${line}`));
+    const answer = String(await promptForGmailAccount(deps) || '').trim();
+    const number = /^\d+$/.test(answer) ? Number(answer) : 0;
+    selector = number >= 1 && number <= sortedAccounts.length
+      ? gmailAccountIdentity(sortedAccounts[number - 1]).id
+      : answer;
+  }
+
+  const match = findGmailAccountForUse(accounts, selector);
+  if (!match) {
+    console.error(`unknown gmail account "${selector}".`);
+    if (accounts.length) {
+      console.error('connected accounts:');
+      for (const account of sortGmailAccounts(accounts)) {
+        const { id, email, name } = gmailAccountIdentity(account);
+        console.error(`  ${id.toLowerCase()}: ${email || 'email pending'}, ${name}`);
+      }
+    } else {
+      console.error('no connected accounts.');
+    }
+    process.exit(1);
+  }
+
+  const { id, name, email } = gmailAccountIdentity(match);
+  writeGmailStickyAccount(id);
+  console.log(`now using ${name} (${email || 'email pending'})`);
+}
+
 async function gmailCommand(subcommand, ...args) {
   switch (subcommand) {
     case 'inbox':
-    case 'list':
-      await gmailInbox();
+    case 'list': {
+      const parsed = parseGmailArgs(args);
+      await gmailInbox({ accountId: parsed.accountId || undefined });
       break;
-    case 'read':
-      await gmailRead(args[0]);
+    }
+    case 'read': {
+      const parsed = parseGmailArgs(args);
+      await gmailRead(parsed.positional[0], { accountId: parsed.accountId || undefined });
       break;
-    case 'archive':
-      await gmailArchive(args);
+    }
+    case 'archive': {
+      const parsed = parseGmailArgs(args);
+      await gmailArchive(parsed.positional, { accountId: parsed.accountId || undefined });
+      break;
+    }
+    case 'send': {
+      const parsed = parseGmailSendArgs(args);
+      await gmailSend(parsed.to, parsed.subject, parsed.body, { accountId: parsed.accountId || undefined });
+      break;
+    }
+    case 'voice': {
+      const parsed = parseGmailVoiceArgs(args);
+      await gmailVoice(parsed.accountId, { clear: parsed.clear });
+      break;
+    }
+    case 'connect':
+      await gmailConnect(args[0]);
+      break;
+    case 'accounts':
+      await gmailAccounts();
+      break;
+    case 'use':
+      await gmailUse(args.join(' '));
       break;
     default:
-      console.log('Gmail commands:');
-      console.log('  atris gmail inbox       - List recent emails');
-      console.log('  atris gmail read <id>   - Read specific email');
-      console.log('  atris gmail archive <id> [...] - Archive messages (reversible, All Mail keeps them)');
+      console.log('gmail commands:');
+      console.log('  atris gmail inbox [--account <id>]       - list recent emails for a mailbox');
+      console.log('  atris gmail read <id> [--account <id>]   - read specific email');
+      console.log('  atris gmail archive <id> [...] [--account <id>] - archive messages (reversible, all mail keeps them)');
+      console.log('  atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>] - send an email');
+      console.log('  atris gmail voice [account] [--clear]    - edit or clear an account writing voice');
+      console.log('  atris gmail connect [name]               - connect or reconnect a gmail account');
+      console.log('  atris gmail accounts                     - list connected gmail accounts and the active account');
+      console.log('  atris gmail use [<account_id|name>]      - choose or set the active gmail account');
   }
 }
 
@@ -228,7 +695,8 @@ function formatCalendarTimeRange(event) {
 
 function formatCalendarEvents(label, events) {
   if (events.length === 0) {
-    console.log(`No events ${label}. 🎉`);
+    // label is already a phrase like "today's events" or "events on 2026-08-24"
+    console.log(`No ${label}.`);
     return;
   }
 
@@ -599,7 +1067,15 @@ async function calendarCommand(subcommand, ...args) {
 // ============================================================================
 
 async function twitterPost(args = []) {
-  const outbound = prepareOutboundSendTextOrExit('twitter', args);
+  const approved = args.includes('--approved') || args.includes('--confirm-approved');
+  const cleaned = args.filter((a) => a !== '--approved' && a !== '--confirm-approved');
+  if (!approved) {
+    console.error('Refusing to post without --approved after the exact text is confirmed.');
+    console.error('Usage: atris twitter post "<text>" --approved');
+    process.exit(2);
+  }
+
+  const outbound = prepareOutboundSendTextOrExit('twitter', cleaned);
   let text = outbound.body;
   if (!text) {
     const readline = require('readline');
@@ -658,7 +1134,7 @@ async function twitterCommand(subcommand, ...args) {
       break;
     default:
       console.log('Twitter commands:');
-      console.log('  atris twitter post [text]  - Post a tweet');
+      console.log('  atris twitter post "<text>" --approved  - Post a tweet');
   }
 }
 
@@ -834,9 +1310,16 @@ async function slackSearch(query, args = []) {
 
 async function slackSend(channel, textParts) {
   const target = String(channel || '').trim();
-  const text = prepareOutboundSendTextOrExit('slack', textParts).body;
+  const approved = (textParts || []).includes('--approved') || (textParts || []).includes('--confirm-approved');
+  const cleaned = (textParts || []).filter((a) => a !== '--approved' && a !== '--confirm-approved');
+  if (!approved) {
+    console.error('Refusing to send without --approved after the exact channel and exact text are confirmed.');
+    console.error('Usage: atris slack send <channel> "<message>" --approved');
+    process.exit(2);
+  }
+  const text = prepareOutboundSendTextOrExit('slack', cleaned).body;
   if (!target || !text) {
-    console.error('Usage: atris slack send <channel> "<message>"');
+    console.error('Usage: atris slack send <channel> "<message>" --approved');
     process.exit(1);
   }
 
@@ -860,9 +1343,16 @@ async function slackSend(channel, textParts) {
 
 async function slackDm(userId, textParts) {
   const target = String(userId || '').trim();
-  const text = prepareOutboundSendTextOrExit('slack', textParts).body;
+  const approved = (textParts || []).includes('--approved') || (textParts || []).includes('--confirm-approved');
+  const cleaned = (textParts || []).filter((a) => a !== '--approved' && a !== '--confirm-approved');
+  if (!approved) {
+    console.error('Refusing to send without --approved after the exact recipient and exact text are confirmed.');
+    console.error('Usage: atris slack dm <slack_user_id> "<message>" --approved');
+    process.exit(2);
+  }
+  const text = prepareOutboundSendTextOrExit('slack', cleaned).body;
   if (!target || !text) {
-    console.error('Usage: atris slack dm <slack_user_id> "<message>"');
+    console.error('Usage: atris slack dm <slack_user_id> "<message>" --approved');
     process.exit(1);
   }
 
@@ -912,8 +1402,8 @@ async function slackCommand(subcommand, ...args) {
       console.log('  atris slack dms                  - List Slack DMs');
       console.log('  atris slack messages <channel>   - Read recent messages');
       console.log('  atris slack search <query>       - Search Slack messages');
-      console.log('  atris slack send <channel> "<message>" - Send a message as you');
-      console.log('  atris slack dm <user_id> "<message>"   - DM someone as you');
+      console.log('  atris slack send <channel> "<message>" --approved - Send a message as you');
+      console.log('  atris slack dm <user_id> "<message>" --approved   - DM someone as you');
   }
 }
 
@@ -1588,10 +2078,41 @@ async function imessageCommand(subcommand, ...args) {
 // STATUS
 // ============================================================================
 
-async function integrationsStatus() {
+async function integrationsStatus(args = []) {
+  const { parseScopeFlag } = require('../lib/cli-scope');
+  const scope = parseScopeFlag(args);
+  const json = scope.args.includes('--json') || args.includes('--json');
+
+  if (!scope.global) {
+    const localPath = path.join(process.cwd(), '.atris', 'integrations.json');
+    let local = null;
+    try {
+      if (fs.existsSync(localPath)) local = JSON.parse(fs.readFileSync(localPath, 'utf8'));
+    } catch {}
+    const payload = {
+      scope: 'workspace',
+      workspace_root: process.cwd(),
+      integrations: Array.isArray(local?.integrations) ? local.integrations : [],
+      note: 'workspace scope only. pass --global for account-level mail/chat/code hosts.',
+    };
+    if (json) {
+      console.log(JSON.stringify(payload, null, 2));
+      return 0;
+    }
+    console.log('Integration Status (workspace)\n');
+    if (!payload.integrations.length) {
+      console.log('  (none configured in this workspace)');
+    } else {
+      for (const name of payload.integrations) console.log(`  • ${name}`);
+    }
+    console.log('\nPass --global to check account-level gmail/slack/github status.');
+    return 0;
+  }
+
   const token = await getAuthToken();
+  const rows = [];
 
-  console.log('🔌 Integration Status:\n');
+  console.log('🔌 Integration Status (global):\n');
 
   const integrations = ['gmail', 'google-calendar', 'slack', 'twitter', 'github'];
 
@@ -1606,19 +2127,32 @@ async function integrationsStatus() {
       const icon = connected ? '✅' : '❌';
       const displayName = name.replace('google-', '').replace('-', ' ');
       console.log(`  ${icon} ${displayName}`);
+      rows.push({ name, connected: Boolean(connected) });
     } catch {
       console.log(`  ❓ ${name}`);
+      rows.push({ name, connected: null });
     }
   }
 
   const imessage = imessageDoctor();
   console.log(`  ${imessage.connected ? '✅' : '❌'} iMessage (local Mac)`);
+  rows.push({ name: 'imessage', connected: Boolean(imessage.connected) });
 
   console.log('\nConnect integrations at: https://atris.ai/dashboard/settings');
+  if (json) {
+    console.log(JSON.stringify({ scope: 'global', integrations: rows }, null, 2));
+  }
+  return 0;
 }
 
 module.exports = {
   gmailCommand,
+  gmailConnect,
+  gmailVoice,
+  gmailUse,
+  extractGmailMailboxAccount,
+  parseGmailArgs,
+  gmailAccountStatePath,
   calendarCommand,
   twitterCommand,
   slackCommand,
@@ -1627,6 +2161,7 @@ module.exports = {
   integrationsStatus,
   parseCalendarSearchArgs,
   filterCalendarEventsForSearch,
+  formatCalendarEvents,
   formatCalendarSearchResults,
   formatCalendarSearchError,
 };