nothumanallowed 6.8.4 → 7.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "6.8.4",
+  "version": "7.1.0",
   "description": "NotHumanAllowed — 38 AI agents for security, code, DevOps, data & daily ops. Per-agent memory, Telegram + Discord auto-responder, proactive intelligence daemon, voice chat, plugin system.",
   "type": "module",
   "bin": {

package/src/commands/ui.mjs

@@ -111,7 +111,34 @@ TOOLS:
     Delete an email. Query can be a messageId OR a search term like "pranzo from:me in:sent".
     The system finds the matching email and moves it to Trash. ALWAYS confirm before deleting.
 
-21. maps_directions(from: string, to: string)
+21. contact_add(name: string, email?: string, phone?: string, company?: string, address?: string)
+    Add a new contact to Google Contacts.
+
+22. contact_update(query: string, email?: string, phone?: string, company?: string, address?: string)
+    Update an existing contact. Query is the contact name to search for.
+
+23. contact_delete(query: string)
+    Delete a contact by name. ALWAYS confirm before deleting.
+
+24. contact_search(query: string)
+    Search contacts by name, email or phone. Returns matching contacts.
+
+25. gtask_list()
+    List Google Tasks (not completed).
+
+26. gtask_add(title: string, notes?: string, due?: string)
+    Add a Google Task. due is YYYY-MM-DD.
+
+27. gtask_complete(title: string)
+    Complete a Google Task by title.
+
+28. note_add(title: string, content?: string)
+    Create a local note.
+
+29. note_list()
+    List all local notes.
+
+30. maps_directions(from: string, to: string)
     Generate a Google Maps directions link between two locations.
 
 RULES:
@@ -417,6 +444,72 @@ async function executeTool(action, params, config) {
       await gm.trashMessage(cfg, messageId);
       return `Email moved to Trash.`;
     }
+    // ── Contacts CRUD ──────────────────────────────────────────────────
+    case 'contact_add': {
+      const gc = await import('../services/google-contacts.mjs');
+      const contact = await gc.createContact(config, {
+        name: params.name, email: params.email, phone: params.phone,
+        company: params.company, address: params.address,
+      });
+      return `Contact created: ${contact.name}${contact.phone ? ' — ' + contact.phone : ''}${contact.email ? ' — ' + contact.email : ''}`;
+    }
+    case 'contact_update': {
+      const gc = await import('../services/google-contacts.mjs');
+      const matches = await gc.searchContacts(config, params.query, 1);
+      if (matches.length === 0) return `No contact found matching "${params.query}".`;
+      const updated = await gc.updateContact(config, matches[0].resourceName, {
+        email: params.email, phone: params.phone, company: params.company, address: params.address,
+      });
+      return `Contact updated: ${updated.name}`;
+    }
+    case 'contact_delete': {
+      const gc = await import('../services/google-contacts.mjs');
+      const matches = await gc.searchContacts(config, params.query, 1);
+      if (matches.length === 0) return `No contact found matching "${params.query}".`;
+      await gc.deleteContact(config, matches[0].resourceName);
+      return `Contact "${matches[0].name}" deleted.`;
+    }
+    case 'contact_search': {
+      const gc = await import('../services/google-contacts.mjs');
+      const contacts = await gc.searchContacts(config, params.query, 10);
+      if (contacts.length === 0) return `No contacts matching "${params.query}".`;
+      return contacts.map((c, i) => `${i + 1}. ${c.name}${c.email ? ' — ' + c.email : ''}${c.phone ? ' — ' + c.phone : ''}${c.company ? ' (' + c.company + ')' : ''}`).join('\n');
+    }
+    // ── Google Tasks CRUD ────────────────────────────────────────────────
+    case 'gtask_list': {
+      const gt = await import('../services/google-tasks.mjs');
+      const tasks = await gt.listTasks(config);
+      if (tasks.length === 0) return 'No active Google Tasks.';
+      return tasks.map((t, i) => `${i + 1}. ${t.title}${t.due ? ' (due: ' + t.due.split('T')[0] + ')' : ''}${t.notes ? ' — ' + t.notes.slice(0, 80) : ''}`).join('\n');
+    }
+    case 'gtask_add': {
+      const gt = await import('../services/google-tasks.mjs');
+      const lists = await gt.listTaskLists(config);
+      const listId = lists[0]?.id || '@default';
+      const task = await gt.createTask(config, listId, params.title, params.notes || '', params.due || '');
+      return `Google Task created: "${task.title}"${task.due ? ' (due: ' + task.due.split('T')[0] + ')' : ''}`;
+    }
+    case 'gtask_complete': {
+      const gt = await import('../services/google-tasks.mjs');
+      const tasks = await gt.listTasks(config);
+      const match = tasks.find(t => t.title.toLowerCase().includes((params.title || '').toLowerCase()));
+      if (!match) return `No task found matching "${params.title}".`;
+      await gt.completeTask(config, match.listId || '@default', match.id);
+      return `Task "${match.title}" completed.`;
+    }
+    // ── Notes CRUD ───────────────────────────────────────────────────────
+    case 'note_add': {
+      const ns = await import('../services/notes.mjs');
+      const note = ns.createNote(params.title || 'Untitled', params.content || '', params.tags || []);
+      return `Note created: "${note.title}"`;
+    }
+    case 'note_list': {
+      const ns = await import('../services/notes.mjs');
+      const notes = ns.listNotes();
+      if (notes.length === 0) return 'No notes.';
+      return notes.map((n, i) => `${i + 1}. ${n.title} (${new Date(n.updatedAt).toLocaleDateString()})`).join('\n');
+    }
+    // ── Maps ─────────────────────────────────────────────────────────────
     case 'maps_directions': {
       const from = encodeURIComponent(params.from || '');
       const to = encodeURIComponent(params.to || '');
@@ -709,6 +802,106 @@ export async function cmdUI(args) {
         return;
       }
 
+      // POST /api/contacts — create contact
+      if (method === 'POST' && pathname === '/api/contacts') {
+        try {
+          const gc = await import('../services/google-contacts.mjs');
+          const body = await parseBody(req);
+          const contact = await gc.createContact(config, body);
+          sendJSON(res, 201, { contact });
+        } catch (e) {
+          sendJSON(res, 200, { error: e.message });
+        }
+        logRequest(method, pathname, 201, Date.now() - start);
+        return;
+      }
+
+      // DELETE /api/contacts/:resourceName
+      if (method === 'POST' && pathname.startsWith('/api/contacts/delete/')) {
+        try {
+          const gc = await import('../services/google-contacts.mjs');
+          const rn = pathname.replace('/api/contacts/delete/', '');
+          await gc.deleteContact(config, 'people/' + rn);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) {
+          sendJSON(res, 200, { error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // GET /api/contacts — list or search contacts
+      if (method === 'GET' && pathname === '/api/contacts') {
+        try {
+          const gc = await import('../services/google-contacts.mjs');
+          const q = url.searchParams.get('q');
+          let contacts;
+          if (q) {
+            contacts = await gc.searchContacts(config, q, 20);
+          } else {
+            contacts = await gc.listContacts(config, 50);
+          }
+          sendJSON(res, 200, { contacts });
+        } catch (e) {
+          sendJSON(res, 200, { contacts: [], error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // GET /api/notes — list notes | POST /api/notes — create note
+      if (pathname === '/api/notes' && !pathname.includes('/api/notes/')) {
+        if (method === 'GET') {
+          try {
+            const ns = await import('../services/notes.mjs');
+            const q = url.searchParams.get('q');
+            const notes = q ? ns.searchNotes(q) : ns.listNotes();
+            sendJSON(res, 200, { notes });
+          } catch (e) {
+            sendJSON(res, 200, { notes: [], error: e.message });
+          }
+          logRequest(method, pathname, 200, Date.now() - start);
+          return;
+        }
+        if (method === 'POST') {
+          try {
+            const ns = await import('../services/notes.mjs');
+            const body = await parseBody(req);
+            const note = ns.createNote(body.title || 'Untitled', body.content || '', body.tags || []);
+            sendJSON(res, 201, { note });
+          } catch (e) {
+            sendJSON(res, 200, { error: e.message });
+          }
+          logRequest(method, pathname, 201, Date.now() - start);
+          return;
+        }
+      }
+
+      // GET /api/notes/:id — get note | POST /api/notes/:id — update | POST /api/notes/:id/delete — delete
+      const noteMatch = pathname.match(/^\/api\/notes\/([a-f0-9-]+)(\/delete)?$/);
+      if (noteMatch) {
+        const noteId = noteMatch[1];
+        const isDelete = noteMatch[2] === '/delete';
+        try {
+          const ns = await import('../services/notes.mjs');
+          if (isDelete && method === 'POST') {
+            ns.deleteNote(noteId);
+            sendJSON(res, 200, { ok: true });
+          } else if (method === 'POST') {
+            const body = await parseBody(req);
+            const note = ns.updateNote(noteId, body.title, body.content, body.tags);
+            sendJSON(res, 200, { ok: !!note, note });
+          } else {
+            const note = ns.getNote(noteId);
+            sendJSON(res, 200, { note });
+          }
+        } catch (e) {
+          sendJSON(res, 200, { error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
       // GET /api/drive — list recent Drive files
       if (method === 'GET' && pathname === '/api/drive') {
         try {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '6.8.4';
+export const VERSION = '7.1.0';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/google-contacts.mjs

@@ -0,0 +1,250 @@
+/**
+ * Google People API (Contacts) wrapper — zero dependencies.
+ * All calls via native fetch to People API v1.
+ * Auto-refreshes tokens on 401.
+ */
+
+import { getAccessToken } from './token-store.mjs';
+
+const PEOPLE_BASE = 'https://people.googleapis.com/v1';
+
+const CONTACT_FIELDS = 'names,emailAddresses,phoneNumbers,organizations,birthdays,addresses';
+const CONTACT_FIELDS_FULL = 'names,emailAddresses,phoneNumbers,organizations,birthdays,addresses,biographies,urls';
+
+/** Authenticated fetch with auto-retry on 401 */
+async function peopleFetch(config, urlPath, options = {}) {
+  const token = await getAccessToken(config);
+  const url = urlPath.startsWith('http') ? urlPath : `${PEOPLE_BASE}${urlPath}`;
+
+  let res = await fetch(url, {
+    ...options,
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      ...options.headers,
+    },
+  });
+
+  if (res.status === 401) {
+    const newToken = await getAccessToken(config);
+    res = await fetch(url, {
+      ...options,
+      headers: {
+        ...options.headers,
+        'Authorization': `Bearer ${newToken}`,
+      },
+    });
+  }
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`People API ${res.status}: ${err}`);
+  }
+
+  const text = await res.text();
+  if (!text) return {};
+  try { return JSON.parse(text); } catch { return {}; }
+}
+
+/**
+ * Search contacts by name or email.
+ * @param {object} config
+ * @param {string} query — search term (name, email, phone)
+ * @param {number} maxResults
+ * @returns {Promise<Array>}
+ */
+export async function searchContacts(config, query, maxResults = 10) {
+  const params = new URLSearchParams({
+    query,
+    readMask: CONTACT_FIELDS,
+    sources: 'READ_SOURCE_TYPE_CONTACT',
+    pageSize: String(maxResults),
+  });
+
+  const data = await peopleFetch(config, `/people:searchContacts?${params}`);
+  return (data.results || []).map(r => parseContact(r.person));
+}
+
+/**
+ * List all contacts sorted by first name.
+ * @param {object} config
+ * @param {number} maxResults
+ * @returns {Promise<Array>}
+ */
+export async function listContacts(config, maxResults = 50) {
+  const params = new URLSearchParams({
+    personFields: CONTACT_FIELDS,
+    sortOrder: 'FIRST_NAME_ASCENDING',
+    pageSize: String(Math.min(maxResults, 1000)),
+  });
+
+  const contacts = [];
+  let pageToken = null;
+
+  do {
+    if (pageToken) params.set('pageToken', pageToken);
+    const data = await peopleFetch(config, `/people/me/connections?${params}`);
+    const connections = data.connections || [];
+    contacts.push(...connections.map(parseContact));
+    pageToken = data.nextPageToken || null;
+  } while (pageToken && contacts.length < maxResults);
+
+  return contacts.slice(0, maxResults);
+}
+
+/**
+ * Get a single contact by resourceName (e.g. "people/c1234567890").
+ * @param {object} config
+ * @param {string} resourceName
+ * @returns {Promise<object>}
+ */
+export async function getContact(config, resourceName) {
+  const params = new URLSearchParams({
+    personFields: CONTACT_FIELDS_FULL,
+  });
+
+  const name = resourceName.startsWith('people/') ? resourceName : `people/${resourceName}`;
+  const data = await peopleFetch(config, `/${name}?${params}`);
+  return parseContact(data);
+}
+
+/**
+ * Get all contacts that have a birthday set.
+ * @param {object} config
+ * @returns {Promise<Array>}
+ */
+export async function getBirthdays(config) {
+  const all = await listContacts(config, 1000);
+  return all.filter(c => c.birthday);
+}
+
+/**
+ * Create a new contact.
+ */
+export async function createContact(config, { name, email, phone, company, title, address }) {
+  const body = { names: [], emailAddresses: [], phoneNumbers: [], organizations: [], addresses: [] };
+
+  if (name) {
+    const parts = name.split(' ');
+    body.names.push({ givenName: parts[0], familyName: parts.slice(1).join(' ') || '' });
+  }
+  if (email) body.emailAddresses.push({ value: email });
+  if (phone) body.phoneNumbers.push({ value: phone });
+  if (company || title) body.organizations.push({ name: company || '', title: title || '' });
+  if (address) body.addresses.push({ formattedValue: address });
+
+  const data = await peopleFetch(config, '/people:createContact', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  return parseContact(data);
+}
+
+/**
+ * Update an existing contact.
+ */
+export async function updateContact(config, resourceName, fields) {
+  // First get the current contact to get etag
+  const current = await peopleFetch(config, `/${resourceName}?personFields=names,emailAddresses,phoneNumbers,organizations,addresses`);
+
+  const body = { etag: current.etag };
+  const updateFields = [];
+
+  if (fields.name !== undefined) {
+    const parts = (fields.name || '').split(' ');
+    body.names = [{ givenName: parts[0], familyName: parts.slice(1).join(' ') || '' }];
+    updateFields.push('names');
+  }
+  if (fields.email !== undefined) {
+    body.emailAddresses = [{ value: fields.email }];
+    updateFields.push('emailAddresses');
+  }
+  if (fields.phone !== undefined) {
+    body.phoneNumbers = [{ value: fields.phone }];
+    updateFields.push('phoneNumbers');
+  }
+  if (fields.company !== undefined || fields.title !== undefined) {
+    body.organizations = [{ name: fields.company || '', title: fields.title || '' }];
+    updateFields.push('organizations');
+  }
+  if (fields.address !== undefined) {
+    body.addresses = [{ formattedValue: fields.address }];
+    updateFields.push('addresses');
+  }
+
+  const data = await peopleFetch(config, `/${resourceName}:updateContact?updatePersonFields=${updateFields.join(',')}`, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  return parseContact(data);
+}
+
+/**
+ * Delete a contact.
+ */
+export async function deleteContact(config, resourceName) {
+  await peopleFetch(config, `/${resourceName}:deleteContact`, { method: 'DELETE' });
+  return { ok: true };
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────
+
+function parseContact(raw) {
+  if (!raw) return null;
+
+  const names = raw.names || [];
+  const primaryName = names.find(n => n.metadata?.primary) || names[0] || {};
+
+  const emailAddresses = raw.emailAddresses || [];
+  const primaryEmail = emailAddresses.find(e => e.metadata?.primary) || emailAddresses[0] || {};
+
+  const phoneNumbers = raw.phoneNumbers || [];
+  const primaryPhone = phoneNumbers.find(p => p.metadata?.primary) || phoneNumbers[0] || {};
+
+  const organizations = raw.organizations || [];
+  const primaryOrg = organizations.find(o => o.metadata?.primary) || organizations[0] || {};
+
+  const birthdays = raw.birthdays || [];
+  const primaryBirthday = birthdays.find(b => b.metadata?.primary) || birthdays[0];
+
+  const addresses = raw.addresses || [];
+  const primaryAddress = addresses.find(a => a.metadata?.primary) || addresses[0] || {};
+
+  return {
+    resourceName: raw.resourceName || '',
+    name: primaryName.displayName || '',
+    firstName: primaryName.givenName || '',
+    lastName: primaryName.familyName || '',
+    email: primaryEmail.value || '',
+    emails: emailAddresses.map(e => e.value).filter(Boolean),
+    phone: primaryPhone.value || '',
+    phones: phoneNumbers.map(p => p.value).filter(Boolean),
+    company: primaryOrg.name || '',
+    title: primaryOrg.title || '',
+    birthday: formatBirthday(primaryBirthday),
+    address: formatAddress(primaryAddress),
+  };
+}
+
+function formatBirthday(birthday) {
+  if (!birthday?.date) return '';
+  const { year, month, day } = birthday.date;
+  const mm = String(month).padStart(2, '0');
+  const dd = String(day).padStart(2, '0');
+  if (year) return `${year}-${mm}-${dd}`;
+  return `${mm}-${dd}`;
+}
+
+function formatAddress(address) {
+  if (!address) return '';
+  if (address.formattedValue) return address.formattedValue;
+  const parts = [
+    address.streetAddress,
+    address.city,
+    address.region,
+    address.postalCode,
+    address.country,
+  ].filter(Boolean);
+  return parts.join(', ');
+}

package/src/services/google-oauth.mjs

@@ -22,6 +22,8 @@ const SCOPES = [
   'https://www.googleapis.com/auth/calendar.events',
   'https://www.googleapis.com/auth/drive.readonly',
   'https://www.googleapis.com/auth/drive.metadata.readonly',
+  'https://www.googleapis.com/auth/contacts',
+  'https://www.googleapis.com/auth/tasks',
   'https://www.googleapis.com/auth/userinfo.email',
 ].join(' ');
 

package/src/services/google-tasks.mjs

@@ -0,0 +1,147 @@
+/**
+ * Google Tasks API wrapper — zero dependencies.
+ * All calls via native fetch to Tasks REST API v1.
+ * Auto-refreshes tokens on 401.
+ */
+
+import { getAccessToken } from './token-store.mjs';
+
+const TASKS_BASE = 'https://tasks.googleapis.com/tasks/v1';
+
+/** Authenticated fetch with auto-retry on 401 */
+async function tasksFetch(config, urlPath, options = {}) {
+  const token = await getAccessToken(config);
+  const url = urlPath.startsWith('http') ? urlPath : `${TASKS_BASE}${urlPath}`;
+
+  let res = await fetch(url, {
+    ...options,
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      ...options.headers,
+    },
+  });
+
+  if (res.status === 401) {
+    const newToken = await getAccessToken(config);
+    res = await fetch(url, {
+      ...options,
+      headers: {
+        ...options.headers,
+        'Authorization': `Bearer ${newToken}`,
+      },
+    });
+  }
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Tasks API ${res.status}: ${err}`);
+  }
+
+  // DELETE returns 204 No Content
+  if (res.status === 204) return null;
+
+  return res.json();
+}
+
+/**
+ * List all task lists for the authenticated user.
+ * @param {object} config
+ * @returns {Promise<Array<{id: string, title: string, updated: string}>>}
+ */
+export async function listTaskLists(config) {
+  const data = await tasksFetch(config, '/users/@me/lists');
+  return (data.items || []).map(item => ({
+    id: item.id,
+    title: item.title || '(untitled)',
+    updated: item.updated || '',
+  }));
+}
+
+/**
+ * List tasks in a task list.
+ * @param {object} config
+ * @param {string} taskListId — task list ID, defaults to '@default'
+ * @returns {Promise<Array>}
+ */
+export async function listTasks(config, taskListId = '@default') {
+  const params = new URLSearchParams({
+    showCompleted: 'false',
+    maxResults: '100',
+  });
+
+  const data = await tasksFetch(config, `/lists/${encodeURIComponent(taskListId)}/tasks?${params}`);
+  return (data.items || []).map(item => parseTask(item, taskListId));
+}
+
+/**
+ * Create a new task.
+ * @param {object} config
+ * @param {string} taskListId
+ * @param {string} title
+ * @param {string} [notes]
+ * @param {string} [due] — RFC 3339 date-time string
+ * @returns {Promise<object>}
+ */
+export async function createTask(config, taskListId, title, notes, due) {
+  const body = { title };
+  if (notes) body.notes = notes;
+  if (due) body.due = due;
+
+  const data = await tasksFetch(config, `/lists/${encodeURIComponent(taskListId)}/tasks`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+
+  return parseTask(data, taskListId);
+}
+
+/**
+ * Mark a task as completed.
+ * @param {object} config
+ * @param {string} taskListId
+ * @param {string} taskId
+ * @returns {Promise<object>}
+ */
+export async function completeTask(config, taskListId, taskId) {
+  const data = await tasksFetch(
+    config,
+    `/lists/${encodeURIComponent(taskListId)}/tasks/${encodeURIComponent(taskId)}`,
+    {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ status: 'completed' }),
+    },
+  );
+
+  return parseTask(data, taskListId);
+}
+
+/**
+ * Delete a task.
+ * @param {object} config
+ * @param {string} taskListId
+ * @param {string} taskId
+ * @returns {Promise<void>}
+ */
+export async function deleteTask(config, taskListId, taskId) {
+  await tasksFetch(
+    config,
+    `/lists/${encodeURIComponent(taskListId)}/tasks/${encodeURIComponent(taskId)}`,
+    { method: 'DELETE' },
+  );
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────
+
+function parseTask(raw, listId) {
+  return {
+    id: raw.id,
+    title: raw.title || '',
+    notes: raw.notes || '',
+    status: raw.status || 'needsAction',
+    due: raw.due || '',
+    updated: raw.updated || '',
+    listId: listId || '',
+  };
+}