atris 3.31.0 → 3.33.3

package/commands/integrations.js

@@ -124,6 +124,32 @@ async function gmailRead(messageId) {
   console.log(msg.body || msg.snippet || '(no body)');
 }
 
+async function gmailArchive(messageIds) {
+  const ids = (messageIds || []).map(id => String(id || '').trim()).filter(Boolean);
+  if (!ids.length) {
+    console.error('Usage: atris gmail archive <message_id> [<message_id> ...]');
+    process.exit(1);
+  }
+
+  const token = await getAuthToken();
+
+  console.log(`Archiving ${ids.length} message${ids.length === 1 ? '' : 's'}...`);
+
+  const result = await apiRequestJson('/integrations/gmail/messages/batch-archive', {
+    method: 'POST',
+    token,
+    body: { message_ids: ids },
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to archive'}`);
+    process.exit(1);
+  }
+
+  const archived = result.data?.archived ?? result.data?.count ?? ids.length;
+  console.log(`Archived ${archived} message${archived === 1 ? '' : 's'}. They stay searchable in All Mail.`);
+}
+
 async function gmailCommand(subcommand, ...args) {
   switch (subcommand) {
     case 'inbox':
@@ -133,10 +159,14 @@ async function gmailCommand(subcommand, ...args) {
     case 'read':
       await gmailRead(args[0]);
       break;
+    case 'archive':
+      await gmailArchive(args);
+      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)');
   }
 }
 
@@ -474,6 +504,58 @@ async function calendarDate(dateText) {
   await calendarRange(`Events on ${dateText}`, { timeMin: start.toISOString(), timeMax: end.toISOString() });
 }
 
+async function calendarAdd(args) {
+  // atris calendar add "Title" --date YYYY-MM-DD --from HH:MM --to HH:MM
+  //   or: --start <ISO> --end <ISO>; optional --location, --description
+  const rest = [...(args || [])];
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = String(rest[i] || '');
+    if (arg.startsWith('--')) {
+      flags[arg.slice(2)] = String(rest[i + 1] || '');
+      i += 1;
+    } else {
+      positional.push(arg);
+    }
+  }
+  const summary = positional.join(' ').trim();
+  let start = String(flags.start || '').trim();
+  let end = String(flags.end || '').trim();
+  if (!start && flags.date && flags.from) start = `${flags.date}T${flags.from}:00`;
+  if (!end && flags.date && flags.to) end = `${flags.date}T${flags.to}:00`;
+  if (!summary || !start || !end) {
+    console.error('Usage: atris calendar add "Title" --date YYYY-MM-DD --from HH:MM --to HH:MM');
+    console.error('   or: atris calendar add "Title" --start <ISO datetime> --end <ISO datetime>');
+    process.exit(1);
+  }
+
+  const token = await getAuthToken();
+
+  console.log(`Creating event: ${summary} (${start} to ${end})...`);
+
+  const body = { summary, start, end };
+  if (flags.location) body.location = flags.location;
+  if (flags.description) body.description = flags.description;
+  if (flags.timezone) body.timezone = flags.timezone;
+
+  const result = await apiRequestJson('/integrations/google-calendar/events', {
+    method: 'POST',
+    token,
+    body,
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to create event'}`);
+    process.exit(1);
+  }
+
+  const created = result.data || {};
+  console.log(`Created: ${created.summary || summary}`);
+  if (created.htmlLink) console.log(`Link: ${created.htmlLink}`);
+  console.log(`Verified on calendar: ${created.verified ? 'yes' : 'no'}`);
+}
+
 async function calendarCommand(subcommand, ...args) {
   switch (subcommand) {
     case 'today':
@@ -492,6 +574,10 @@ async function calendarCommand(subcommand, ...args) {
     case 'search':
       await calendarSearch(args);
       break;
+    case 'add':
+    case 'create':
+      await calendarAdd(args);
+      break;
     default:
       console.log('Calendar commands:');
       console.log('  atris calendar today          - Show today\'s events');
@@ -499,6 +585,7 @@ async function calendarCommand(subcommand, ...args) {
       console.log('  atris calendar week           - Show this week\'s events');
       console.log('  atris calendar date YYYY-MM-DD - Show events on a date');
       console.log('  atris calendar search <query> [--days 30] [--limit 20] [--timeout-ms 10000] [--json] - Search upcoming events');
+      console.log('  atris calendar add \"Title\" --date YYYY-MM-DD --from HH:MM --to HH:MM - Create an event');
   }
 }
 
@@ -737,6 +824,58 @@ async function slackSearch(query, args = []) {
   formatSlackMessages(messages);
 }
 
+async function slackSend(channel, textParts) {
+  const target = String(channel || '').trim();
+  const text = (textParts || []).join(' ').trim();
+  if (!target || !text) {
+    console.error('Usage: atris slack send <channel> "<message>"');
+    process.exit(1);
+  }
+
+  const token = await getAuthToken();
+
+  console.log(`Sending to ${target}...`);
+
+  const result = await apiRequestJson('/integrations/slack/me/send', {
+    method: 'POST',
+    token,
+    body: { channel: target, text },
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to send'}`);
+    process.exit(1);
+  }
+
+  console.log(`Sent to ${target} as you.`);
+}
+
+async function slackDm(userId, textParts) {
+  const target = String(userId || '').trim();
+  const text = (textParts || []).join(' ').trim();
+  if (!target || !text) {
+    console.error('Usage: atris slack dm <slack_user_id> "<message>"');
+    process.exit(1);
+  }
+
+  const token = await getAuthToken();
+
+  console.log(`Sending DM to ${target}...`);
+
+  const result = await apiRequestJson('/integrations/slack/me/dm', {
+    method: 'POST',
+    token,
+    body: { slack_user_id: target, text },
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to send DM'}`);
+    process.exit(1);
+  }
+
+  console.log(`DM sent to ${target} as you.`);
+}
+
 async function slackCommand(subcommand, ...args) {
   switch (subcommand) {
     case 'channels':
@@ -753,12 +892,20 @@ async function slackCommand(subcommand, ...args) {
     case 'search':
       await slackSearch(argsWithoutLimit(args).join(' '), args);
       break;
+    case 'send':
+      await slackSend(args[0], args.slice(1));
+      break;
+    case 'dm':
+      await slackDm(args[0], args.slice(1));
+      break;
     default:
       console.log('Slack commands:');
       console.log('  atris slack channels             - List Slack channels');
       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');
   }
 }
 

package/commands/member.js

@@ -611,6 +611,89 @@ function startMemberRunMission(name, missionText, args = []) {
   }
 }
 
+// atris member ping <name> "<message>" — talk to a busy member mid-run.
+// Two delivery lanes: the member's most recently touched live mission
+// (including --worktree missions in sibling checkouts), whose next tick
+// consumes the note, and the member's claimed task dialogue, which task-loop
+// agents re-read every step without ever ticking a mission. The ping lands on
+// every lane that exists and errors only when neither does.
+function pingClaimedTaskDialogue(name, text, from) {
+  let taskDb;
+  try {
+    taskDb = require('../lib/task-db');
+  } catch {
+    return null;
+  }
+  try {
+    const db = taskDb.open();
+    const local = taskDb.listTasks(db, { workspaceRoot: taskDb.workspaceRoot(), status: 'claimed', claimedBy: name });
+    const pool = local.length ? local : taskDb.listTasks(db, { status: 'claimed', claimedBy: name });
+    if (!pool.length) return null;
+    const task = [...pool].sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0))[0];
+    const result = taskDb.noteTask(db, { id: task.id, actor: from, content: text });
+    if (!result.noted) return null;
+    return { task_id: task.id, title: task.title };
+  } catch {
+    return null;
+  }
+}
+
+function memberPing(name, ...args) {
+  if (!name || name === '--help' || name === '-h') {
+    console.log('Usage: atris member ping <name> "<message>" [--from <who>] [--json]');
+    console.log('Leaves the note on the member\'s active mission and claimed task dialogue; whichever loop the member runs reads it next.');
+    return;
+  }
+  const asJson = args.includes('--json');
+  const rest = args.filter((a) => a !== '--json');
+  let from = process.env.USER || 'operator';
+  const fromIdx = rest.indexOf('--from');
+  if (fromIdx !== -1) {
+    from = rest[fromIdx + 1] || from;
+    rest.splice(fromIdx, 2);
+  }
+  const text = rest.filter((a) => !a.startsWith('--')).join(' ').trim();
+  if (!text) {
+    console.error('atris member ping: message required');
+    process.exit(2);
+  }
+  const missionMod = require('./mission');
+  const terminal = new Set(['complete', 'stopped', 'failed']);
+  const candidates = [
+    ...missionMod.listMissions(process.cwd()),
+    ...missionMod.listWorktreeRollupMissions(process.cwd()),
+  ]
+    .filter((m) => m && m.owner === name && !terminal.has(m.status))
+    .sort((a, b) => String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || '')));
+
+  const taskNote = pingClaimedTaskDialogue(name, text, from);
+
+  if (!candidates.length && !taskNote) {
+    console.error(`atris member ping: no live mission or claimed task for "${name}". Start one: atris member run ${name} "<objective>"`);
+    process.exit(1);
+  }
+
+  const mission = candidates.length
+    ? missionMod.pingMission([candidates[0].id, text, '--from', from], { silent: true })
+    : null;
+  const pendingPings = mission ? (mission.pings || []).filter((p) => p && !p.consumed_at).length : null;
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: true,
+      action: 'member_ping',
+      member: name,
+      mission_id: mission ? mission.id : null,
+      pending_pings: pendingPings,
+      task_id: taskNote ? taskNote.task_id : null,
+    }));
+  } else {
+    if (mission) console.log(`pinged ${mission.id} — the next tick reads it (${pendingPings} unread).`);
+    if (taskNote) console.log(`pinged task ${taskNote.task_id} dialogue — ${name} reads it on the next step.`);
+  }
+  return { mission, task_note: taskNote };
+}
+
 function memberRun(name, ...args) {
   if (!name || name === '--help' || name === '-h' || hasFlag(args, '--help') || hasFlag(args, '-h')) {
     console.log('Usage: atris member run <name> ["mission text"] [--minutes N|--hours N] [--json]');
@@ -8063,6 +8146,8 @@ async function memberCommand(subcommand, ...args) {
       return memberWake(args[0], ...args.slice(1));
     case 'run':
       return memberRun(args[0], ...args.slice(1));
+    case 'ping':
+      return memberPing(args[0], ...args.slice(1));
     case 'loop':
       return memberLoop(args[0], ...args.slice(1));
     case 'alive':