nothumanallowed 2.1.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "2.1.0",
+  "version": "3.0.1",
   "description": "NotHumanAllowed — 38 AI agents for security, code, DevOps, data & daily ops. Ask agents directly, plan your day with 5 specialist agents, manage tasks, connect Gmail + Calendar.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -13,6 +13,7 @@ import { cmdPlan } from './commands/plan.mjs';
 import { cmdTasks } from './commands/tasks.mjs';
 import { cmdOps } from './commands/ops.mjs';
 import { cmdChat } from './commands/chat.mjs';
+import { cmdUI } from './commands/ui.mjs';
 import { cmdGoogle } from './commands/google-auth.mjs';
 import { banner, info, ok, warn, fail, C, G, Y, D, W, BOLD, NC, M, B, R } from './ui.mjs';
 
@@ -58,6 +59,9 @@ export async function main(argv) {
     case 'chat':
       return cmdChat(args);
 
+    case 'ui':
+      return cmdUI(args);
+
     case 'google':
       return cmdGoogle(args);
 
@@ -355,6 +359,8 @@ function cmdHelp() {
   console.log(`    run "prompt" ${D}--agents saber,zero${NC}   Collaborate with specific agents\n`);
 
   console.log(`  ${C}Daily Operations${NC}  ${D}(Gmail + Calendar + Tasks)${NC}`);
+  console.log(`    ui                    Open local web dashboard (http://127.0.0.1:3847)`);
+  console.log(`    ui --port=4000        Custom port    ui --no-browser  Don't auto-open`);
   console.log(`    chat                  Interactive chat — manage email/calendar/tasks naturally`);
   console.log(`    plan                  Generate daily plan (5 agents analyze your day)`);
   console.log(`    plan --refresh        Regenerate today's plan`);

package/src/commands/ui.mjs

@@ -0,0 +1,632 @@
+/**
+ * nha ui — Local web interface for NHA operations.
+ *
+ * Starts a zero-dependency HTTP server on localhost:3847 serving a single-page
+ * operations console with REST API endpoints that reuse existing services.
+ *
+ * Zero npm dependencies — Node.js 22 native http module only.
+ */
+
+import http from 'http';
+import { exec } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from '../config.mjs';
+import { callLLM, callAgent, parseAgentFile } from '../services/llm.mjs';
+import { getUnreadImportant } from '../services/google-gmail.mjs';
+import { getTodayEvents } from '../services/google-calendar.mjs';
+import {
+  getTasks,
+  addTask,
+  completeTask,
+  getDayStats,
+} from '../services/task-store.mjs';
+import { runPlanningPipeline } from '../services/ops-pipeline.mjs';
+import { AGENTS, AGENTS_DIR, NHA_DIR, VERSION } from '../constants.mjs';
+import { getHTML } from '../services/web-ui.mjs';
+import { info, ok, fail, warn, C, G, D, NC, BOLD } from '../ui.mjs';
+
+// ── Constants ──────────────────────────────────────────────────────────────
+
+const DEFAULT_PORT = 3847;
+const HOST = '127.0.0.1';
+
+// ── Chat system prompt (reused from chat.mjs) ──────────────────────────────
+
+const TOOL_DEFINITIONS = `
+You have access to the following tools. When the user's message requires an action,
+output EXACTLY ONE fenced JSON block per action:
+
+\`\`\`json
+{"action": "<tool_name>", "params": { ... }}
+\`\`\`
+
+You may include conversational text BEFORE or AFTER the JSON block. If no action
+is needed, respond normally without any JSON block.
+
+TOOLS:
+
+1. gmail_list(query: string, maxResults?: number)
+   Search emails. query uses Gmail search syntax.
+
+2. gmail_read(messageId: string)
+   Read the full body of an email by its ID.
+
+3. gmail_send(to: string, subject: string, body: string)
+   Send an email. ALWAYS confirm with the user before sending.
+
+4. gmail_draft(to: string, subject: string, body: string)
+   Create a draft email (safe — does not send).
+
+5. gmail_reply(messageId: string, body: string)
+   Reply to an existing email thread. ALWAYS confirm before sending.
+
+6. calendar_today()
+   List all events for today.
+
+7. calendar_upcoming(hours?: number)
+   List upcoming events in the next N hours (default 2).
+
+8. calendar_create(summary: string, start: string, end: string, attendees?: string[], description?: string)
+   Create a calendar event. start/end are ISO 8601 datetime strings.
+
+9. task_list()
+   List today's tasks.
+
+10. task_add(description: string, priority?: "low"|"medium"|"high"|"critical", due?: string)
+    Add a new task for today.
+
+11. task_done(id: number)
+    Mark a task as completed.
+
+RULES:
+- For search/read operations, execute immediately and present results conversationally.
+- For write/send/delete operations, describe what you're about to do and include the JSON block.
+- When presenting results, format them clearly in natural language. Never dump raw JSON to the user.
+- If you need multiple actions in sequence, do them ONE AT A TIME.
+- Dates: today is {{TODAY}}. The user's timezone is {{TIMEZONE}}.
+`.trim();
+
+// ── Reuse the executeTool and parseActions logic from chat.mjs ──────────
+
+import {
+  listMessages,
+  getMessage,
+  sendEmail,
+  createDraft,
+} from '../services/google-gmail.mjs';
+
+import {
+  getUpcomingEvents,
+  createEvent,
+} from '../services/google-calendar.mjs';
+
+function parseActions(text) {
+  const actions = [];
+  const textParts = [];
+  const fenceRegex = /```json\s*\n?([\s\S]*?)```/g;
+  let lastIndex = 0;
+  let match;
+
+  while ((match = fenceRegex.exec(text)) !== null) {
+    const before = text.slice(lastIndex, match.index).trim();
+    if (before) textParts.push(before);
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      if (parsed.action && typeof parsed.action === 'string') {
+        actions.push({ action: parsed.action, params: parsed.params || {} });
+      }
+    } catch {
+      textParts.push(match[0]);
+    }
+    lastIndex = match.index + match[0].length;
+  }
+
+  const trailing = text.slice(lastIndex).trim();
+  if (trailing) textParts.push(trailing);
+  return { textParts, actions };
+}
+
+async function executeTool(action, params, config) {
+  switch (action) {
+    case 'gmail_list': {
+      const query = params.query || 'is:unread';
+      const max = params.maxResults || 10;
+      const refs = await listMessages(config, query, max);
+      if (refs.length === 0) return 'No emails found matching that query.';
+      const messages = [];
+      for (const ref of refs.slice(0, max)) {
+        try { messages.push(await getMessage(config, ref.id)); } catch {}
+      }
+      return messages.map((m, i) =>
+        `${i + 1}. [${m.id}] From: ${m.from} | Subject: ${m.subject} | Date: ${m.date}\n   ${m.snippet.slice(0, 120)}`
+      ).join('\n');
+    }
+    case 'gmail_read': {
+      const msg = await getMessage(config, params.messageId);
+      return `From: ${msg.from}\nTo: ${msg.to}\nSubject: ${msg.subject}\nDate: ${msg.date}\n---\n${msg.body.slice(0, 4000)}`;
+    }
+    case 'gmail_send': {
+      await sendEmail(config, params.to, params.subject, params.body);
+      return `Email sent to ${params.to} with subject "${params.subject}".`;
+    }
+    case 'gmail_draft': {
+      await createDraft(config, params.to, params.subject, params.body);
+      return `Draft created for ${params.to} with subject "${params.subject}".`;
+    }
+    case 'gmail_reply': {
+      const original = await getMessage(config, params.messageId);
+      await sendEmail(config, original.from, `Re: ${original.subject}`, params.body, {
+        replyToMessageId: original.id,
+        threadId: original.threadId,
+      });
+      return `Reply sent to ${original.from} on thread "${original.subject}".`;
+    }
+    case 'calendar_today': {
+      const events = await getTodayEvents(config);
+      if (events.length === 0) return 'No events scheduled for today.';
+      return events.map((e, i) => {
+        const time = e.isAllDay ? 'All day' : `${fmtTime(e.start)} - ${fmtTime(e.end)}`;
+        return `${i + 1}. ${time} — ${e.summary}${e.location ? ' @ ' + e.location : ''}`;
+      }).join('\n');
+    }
+    case 'calendar_upcoming': {
+      const hours = params.hours || 2;
+      const events = await getUpcomingEvents(config, hours);
+      if (events.length === 0) return `No events in the next ${hours} hour(s).`;
+      return events.map((e, i) => {
+        const time = e.isAllDay ? 'All day' : `${fmtTime(e.start)} - ${fmtTime(e.end)}`;
+        return `${i + 1}. ${time} — ${e.summary}`;
+      }).join('\n');
+    }
+    case 'calendar_create': {
+      await createEvent(config, {
+        summary: params.summary,
+        start: params.start,
+        end: params.end,
+        description: params.description || '',
+        attendees: params.attendees || [],
+      });
+      return `Event "${params.summary}" created for ${fmtTime(params.start)} - ${fmtTime(params.end)}.`;
+    }
+    case 'task_list': {
+      const tasks = getTasks();
+      if (tasks.length === 0) return 'No tasks for today.';
+      return tasks.map(t =>
+        `#${t.id} [${t.priority}] ${t.status === 'done' ? '[DONE] ' : ''}${t.description}${t.due ? ' (due: ' + t.due + ')' : ''}`
+      ).join('\n');
+    }
+    case 'task_add': {
+      const task = addTask({
+        description: params.description,
+        priority: params.priority || 'medium',
+        due: params.due || null,
+        source: 'chat',
+      });
+      return `Task #${task.id} added: "${task.description}" [${task.priority}]`;
+    }
+    case 'task_done': {
+      const success = completeTask(params.id);
+      return success ? `Task #${params.id} marked as done.` : `Task #${params.id} not found.`;
+    }
+    default:
+      return `Unknown action: ${action}`;
+  }
+}
+
+function fmtTime(isoStr) {
+  try {
+    return new Date(isoStr).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: true });
+  } catch { return isoStr; }
+}
+
+// ── Agent loader ──────────────────────────────────────────────────────────
+
+function loadAgentCards() {
+  const cards = [];
+  for (const name of AGENTS) {
+    const file = path.join(AGENTS_DIR, `${name}.mjs`);
+    let card = { name, category: 'agent', tagline: '' };
+    try {
+      if (fs.existsSync(file)) {
+        const source = fs.readFileSync(file, 'utf-8');
+        const parsed = parseAgentFile(source, name);
+        card = { name, ...parsed.card };
+      }
+    } catch {}
+    cards.push(card);
+  }
+  return cards;
+}
+
+// ── Plan file loader ──────────────────────────────────────────────────────
+
+function loadTodayPlan() {
+  const dateStr = new Date().toISOString().split('T')[0];
+  const planFile = path.join(NHA_DIR, 'ops', 'plans', `${dateStr}.json`);
+  if (fs.existsSync(planFile)) {
+    try { return JSON.parse(fs.readFileSync(planFile, 'utf-8')); }
+    catch { return null; }
+  }
+  return null;
+}
+
+// ── HTTP Helpers ──────────────────────────────────────────────────────────
+
+function sendJSON(res, statusCode, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET,POST,PATCH,OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type',
+    'Cache-Control': 'no-cache',
+  });
+  res.end(body);
+}
+
+function sendHTML(res, html) {
+  res.writeHead(200, {
+    'Content-Type': 'text/html; charset=utf-8',
+    'Cache-Control': 'no-cache',
+  });
+  res.end(html);
+}
+
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    const MAX = 1_048_576; // 1 MB
+    req.on('data', chunk => {
+      size += chunk.length;
+      if (size > MAX) { reject(new Error('Body too large')); req.destroy(); return; }
+      chunks.push(chunk);
+    });
+    req.on('end', () => {
+      try {
+        const raw = Buffer.concat(chunks).toString('utf-8');
+        resolve(raw ? JSON.parse(raw) : {});
+      } catch (e) { reject(e); }
+    });
+    req.on('error', reject);
+  });
+}
+
+// ── Open browser ──────────────────────────────────────────────────────────
+
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === 'darwin' ? 'open' : platform === 'win32' ? 'start' : 'xdg-open';
+  exec(`${cmd} ${url}`, () => {});
+}
+
+// ── Request logger ──────────────────────────────────────────────────────────
+
+function logRequest(method, url, statusCode, durationMs) {
+  const color = statusCode < 400 ? G : '\x1b[0;31m';
+  console.log(`  ${D}${new Date().toISOString().slice(11,19)}${NC}  ${color}${statusCode}${NC}  ${method.padEnd(6)} ${url}  ${D}${durationMs}ms${NC}`);
+}
+
+// ── Server ───────────────────────────────────────────────────────────────
+
+export async function cmdUI(args) {
+  // Parse port flag
+  let port = DEFAULT_PORT;
+  let noBrowser = false;
+  for (const arg of args) {
+    if (arg.startsWith('--port=')) {
+      port = parseInt(arg.split('=')[1], 10) || DEFAULT_PORT;
+    } else if (arg === '--no-browser') {
+      noBrowser = true;
+    }
+  }
+
+  const config = loadConfig();
+  const htmlPage = getHTML(port);
+
+  // Pre-load agent cards once at startup
+  const agentCards = loadAgentCards();
+
+  // Chat session state (persists across requests while server is running)
+  const chatSystemPrompt = (() => {
+    const today = new Date().toISOString().split('T')[0];
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    let prompt = TOOL_DEFINITIONS.replace('{{TODAY}}', today).replace('{{TIMEZONE}}', tz);
+    prompt += `\n\nYou are NHA Chat, a personal operations assistant inside the NotHumanAllowed web UI. ` +
+      `You help the user manage their emails, calendar, and tasks through natural conversation. ` +
+      `Be concise, helpful, and proactive. When presenting data, format it clearly. ` +
+      `Never output raw JSON to the user.`;
+    return prompt;
+  })();
+
+  // ── Route Handlers ──────────────────────────────────────────────────────
+
+  async function handleRequest(req, res) {
+    const start = Date.now();
+    const url = new URL(req.url, `http://${HOST}:${port}`);
+    const pathname = url.pathname;
+    const method = req.method;
+
+    // CORS preflight
+    if (method === 'OPTIONS') {
+      res.writeHead(204, {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET,POST,PATCH,OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+      });
+      res.end();
+      return;
+    }
+
+    try {
+      // ── Serve HTML page ─────────────────────────────────────────────
+      if (method === 'GET' && (pathname === '/' || pathname === '/index.html')) {
+        sendHTML(res, htmlPage);
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // ── Favicon (no-content) ──────────────────────────────────────────
+      if (pathname === '/favicon.ico') {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+
+      // ── API Routes ────────────────────────────────────────────────────
+
+      // GET /api/status
+      if (method === 'GET' && pathname === '/api/status') {
+        sendJSON(res, 200, {
+          connected: true,
+          version: VERSION,
+          provider: config.llm.provider,
+          hasApiKey: !!config.llm.apiKey,
+          hasGoogle: !!config.google?.clientId,
+          agentName: config.agent?.name || null,
+          timestamp: new Date().toISOString(),
+        });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // GET /api/emails
+      if (method === 'GET' && pathname === '/api/emails') {
+        try {
+          const emails = await getUnreadImportant(config, 20);
+          sendJSON(res, 200, { emails });
+        } catch (e) {
+          sendJSON(res, 200, { emails: [], error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // GET /api/calendar
+      if (method === 'GET' && pathname === '/api/calendar') {
+        try {
+          const events = await getTodayEvents(config);
+          sendJSON(res, 200, { events });
+        } catch (e) {
+          sendJSON(res, 200, { events: [], error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // GET /api/tasks
+      if (method === 'GET' && pathname === '/api/tasks') {
+        const tasks = getTasks();
+        const stats = getDayStats();
+        sendJSON(res, 200, { tasks, stats });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/tasks
+      if (method === 'POST' && pathname === '/api/tasks') {
+        const body = await parseBody(req);
+        if (!body.description) {
+          sendJSON(res, 400, { error: 'description required' });
+          logRequest(method, pathname, 400, Date.now() - start);
+          return;
+        }
+        const task = addTask({
+          description: body.description,
+          priority: body.priority || 'medium',
+          due: body.due || null,
+          source: 'web-ui',
+        });
+        sendJSON(res, 201, { task });
+        logRequest(method, pathname, 201, Date.now() - start);
+        return;
+      }
+
+      // PATCH /api/tasks/:id/done
+      const taskDoneMatch = pathname.match(/^\/api\/tasks\/(\d+)\/done$/);
+      if (method === 'PATCH' && taskDoneMatch) {
+        const taskId = parseInt(taskDoneMatch[1], 10);
+        const success = completeTask(taskId);
+        sendJSON(res, 200, { ok: success, id: taskId });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // GET /api/plan
+      if (method === 'GET' && pathname === '/api/plan') {
+        const plan = loadTodayPlan();
+        sendJSON(res, 200, { plan });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/plan/refresh
+      if (method === 'POST' && pathname === '/api/plan/refresh') {
+        try {
+          const plan = await runPlanningPipeline(config, { refresh: true });
+          sendJSON(res, 200, { plan });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/chat
+      if (method === 'POST' && pathname === '/api/chat') {
+        const body = await parseBody(req);
+        if (!body.message) {
+          sendJSON(res, 400, { error: 'message required' });
+          logRequest(method, pathname, 400, Date.now() - start);
+          return;
+        }
+
+        if (!config.llm.apiKey) {
+          sendJSON(res, 200, { response: 'No API key configured. Run: nha config set key YOUR_KEY', error: 'no_api_key' });
+          logRequest(method, pathname, 200, Date.now() - start);
+          return;
+        }
+
+        // Build message with history
+        const history = body.history || [];
+        const parts = [];
+        for (const turn of history) {
+          const prefix = turn.role === 'user' ? '[User]' : '[Assistant]';
+          parts.push(`${prefix} ${turn.content}`);
+        }
+        parts.push(`[User] ${body.message}`);
+        const userMessage = parts.join('\n\n');
+
+        try {
+          const response = await callLLM(config, chatSystemPrompt, userMessage);
+          const { textParts, actions } = parseActions(response);
+          const textResponse = textParts.join('\n\n');
+
+          // Execute non-destructive tool actions automatically
+          let toolResult = null;
+          if (actions.length > 0) {
+            const { action, params } = actions[0];
+            // Skip destructive actions in web UI for safety (gmail_send, gmail_reply, calendar_create)
+            const safeActions = new Set([
+              'gmail_list', 'gmail_read', 'gmail_draft',
+              'calendar_today', 'calendar_upcoming',
+              'task_list', 'task_add', 'task_done',
+            ]);
+            if (safeActions.has(action)) {
+              try {
+                toolResult = await executeTool(action, params, config);
+              } catch (e) {
+                toolResult = `Error: ${e.message}`;
+              }
+            } else {
+              toolResult = `[Action "${action}" requires confirmation. Use nha chat in terminal for write operations.]`;
+            }
+          }
+
+          sendJSON(res, 200, { response: textResponse, toolResult, actions });
+        } catch (e) {
+          sendJSON(res, 200, { response: null, error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // GET /api/agents
+      if (method === 'GET' && pathname === '/api/agents') {
+        sendJSON(res, 200, { agents: agentCards });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/ask
+      if (method === 'POST' && pathname === '/api/ask') {
+        const body = await parseBody(req);
+        if (!body.agent || !body.prompt) {
+          sendJSON(res, 400, { error: 'agent and prompt required' });
+          logRequest(method, pathname, 400, Date.now() - start);
+          return;
+        }
+
+        if (!config.llm.apiKey) {
+          sendJSON(res, 200, { response: null, error: 'No API key configured.' });
+          logRequest(method, pathname, 200, Date.now() - start);
+          return;
+        }
+
+        if (!AGENTS.includes(body.agent)) {
+          sendJSON(res, 400, { error: `Unknown agent: ${body.agent}` });
+          logRequest(method, pathname, 400, Date.now() - start);
+          return;
+        }
+
+        try {
+          const response = await callAgent(config, body.agent, body.prompt);
+          sendJSON(res, 200, { response, agent: body.agent });
+        } catch (e) {
+          sendJSON(res, 200, { response: null, error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // ── 404 ──────────────────────────────────────────────────────────
+      sendJSON(res, 404, { error: 'Not found' });
+      logRequest(method, pathname, 404, Date.now() - start);
+
+    } catch (err) {
+      console.error(`  \x1b[0;31mServer error:\x1b[0m`, err.message);
+      try {
+        sendJSON(res, 500, { error: 'Internal server error' });
+      } catch {}
+      logRequest(method, pathname, 500, Date.now() - start);
+    }
+  }
+
+  // ── Start Server ────────────────────────────────────────────────────────
+
+  const server = http.createServer(handleRequest);
+
+  server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+      fail(`Port ${port} is already in use. Try: nha ui --port=${port + 1}`);
+      process.exit(1);
+    }
+    fail(`Server error: ${err.message}`);
+    process.exit(1);
+  });
+
+  server.listen(port, HOST, () => {
+    const url = `http://${HOST}:${port}`;
+
+    console.log('');
+    console.log(`  ${BOLD}${C}NHA Local Operations Console${NC}`);
+    console.log(`  ${D}Zero-dependency web interface for your daily ops${NC}`);
+    console.log('');
+    console.log(`  ${G}Server running at:${NC}  ${url}`);
+    console.log(`  ${D}Provider:${NC}           ${config.llm.provider || 'not set'}`);
+    console.log(`  ${D}API Key:${NC}            ${config.llm.apiKey ? config.llm.apiKey.slice(0, 12) + '...' : '\x1b[0;31mnot set\x1b[0m'}`);
+    console.log(`  ${D}Agents loaded:${NC}      ${agentCards.length}`);
+    console.log('');
+    console.log(`  ${D}Press Ctrl+C to stop${NC}`);
+    console.log('');
+
+    if (!noBrowser) {
+      openBrowser(url);
+    }
+  });
+
+  // Graceful shutdown
+  const shutdown = () => {
+    console.log(`\n  ${D}Shutting down...${NC}`);
+    server.close(() => {
+      console.log(`  ${D}Server stopped.${NC}\n`);
+      process.exit(0);
+    });
+    // Force exit after 3s if connections hang
+    setTimeout(() => process.exit(0), 3000);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}

package/src/constants.mjs

@@ -1,7 +1,7 @@
 import os from 'os';
 import path from 'path';
 
-export const VERSION = '2.1.0';
+export const VERSION = '3.0.0';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';