agentdev-webui 1.0.0

package/lib/encryption.js

@@ -0,0 +1,112 @@
+const crypto = require('crypto');
+const config = require('./config');
+
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 16;
+const AUTH_TAG_LENGTH = 16;
+
+/**
+ * Get encryption key from config or environment
+ * Must be 32 bytes (64 hex chars)
+ */
+function getEncryptionKey() {
+  const key = config.ENCRYPTION_KEY;
+  if (!key) {
+    throw new Error('ENCRYPTION_SECRET_KEY not configured');
+  }
+
+  // If hex string, convert to buffer
+  if (key.length === 64) {
+    return Buffer.from(key, 'hex');
+  }
+
+  // Otherwise hash it to get 32 bytes
+  return crypto.createHash('sha256').update(key).digest();
+}
+
+/**
+ * Encrypt OAuth secrets
+ * Returns: base64 encoded string with format: iv.authTag.encryptedData
+ */
+function encrypt(text) {
+  if (!text) return null;
+
+  const key = getEncryptionKey();
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+
+  let encrypted = cipher.update(text, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+
+  const authTag = cipher.getAuthTag();
+
+  // Combine: iv.authTag.encrypted
+  const combined = Buffer.concat([
+    iv,
+    authTag,
+    Buffer.from(encrypted, 'hex')
+  ]);
+
+  return combined.toString('base64');
+}
+
+/**
+ * Decrypt OAuth secrets
+ */
+function decrypt(encryptedData) {
+  if (!encryptedData) return null;
+
+  try {
+    const key = getEncryptionKey();
+    const combined = Buffer.from(encryptedData, 'base64');
+
+    // Extract components
+    const iv = combined.slice(0, IV_LENGTH);
+    const authTag = combined.slice(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH);
+    const encrypted = combined.slice(IV_LENGTH + AUTH_TAG_LENGTH);
+
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+
+    let decrypted = decipher.update(encrypted, null, 'utf8');
+    decrypted += decipher.final('utf8');
+
+    return decrypted;
+  } catch (error) {
+    console.error('Decryption failed:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Encrypt OAuth configuration for storage
+ */
+function encryptOAuthConfig(config) {
+  if (!config) return null;
+
+  return {
+    clientId: config.clientId,
+    clientSecretEncrypted: encrypt(config.clientSecret),
+    scopes: config.scopes || ['repo', 'read:org', 'project']
+  };
+}
+
+/**
+ * Decrypt OAuth configuration
+ */
+function decryptOAuthConfig(encryptedConfig) {
+  if (!encryptedConfig) return null;
+
+  return {
+    clientId: encryptedConfig.clientId,
+    clientSecret: decrypt(encryptedConfig.clientSecretEncrypted),
+    scopes: encryptedConfig.scopes || ['repo', 'read:org', 'project']
+  };
+}
+
+module.exports = {
+  encrypt,
+  decrypt,
+  encryptOAuthConfig,
+  decryptOAuthConfig
+};

package/lib/github.js

@@ -0,0 +1,339 @@
+const config = require('./config');
+
+const ORG = config.GITHUB_ORG; // 'data-tamer'
+const ticketCache = new Map();
+
+// Default token management
+let defaultToken = process.env.GITHUB_DEFAULT_TOKEN || process.env.GH_TOKEN || null;
+
+function setDefaultToken(t) { defaultToken = t; }
+
+function getToken(provided) { return provided || defaultToken; }
+
+// --- REST + GraphQL helpers ---
+
+async function ghRest(method, path, token, body = null) {
+  const opts = {
+    method,
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Accept': 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28'
+    }
+  };
+  if (body) {
+    opts.headers['Content-Type'] = 'application/json';
+    opts.body = JSON.stringify(body);
+  }
+  const res = await fetch(`https://api.github.com${path}`, opts);
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`GitHub API ${method} ${path} failed (${res.status}): ${text}`);
+  }
+  if (res.status === 204) return null;
+  return res.json();
+}
+
+async function ghGraphQL(query, variables, token) {
+  const res = await fetch('https://api.github.com/graphql', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`GitHub GraphQL failed (${res.status}): ${text}`);
+  }
+  const json = await res.json();
+  if (json.errors) {
+    throw new Error(`GitHub GraphQL errors: ${JSON.stringify(json.errors)}`);
+  }
+  return json.data;
+}
+
+// --- Exported functions ---
+
+async function fetchTicketDetails(repo, ticket, projectConfig = null) {
+  const org = projectConfig?.github_org || ORG;
+  const cacheKey = `${org}/${repo}/${ticket}`;
+  const cached = ticketCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < config.CACHE_TTL) {
+    return cached.data;
+  }
+
+  try {
+    const token = getToken(null);
+    if (!token) return null;
+
+    const issue = await ghRest('GET', `/repos/${org}/${repo}/issues/${ticket}`, token);
+    const data = {
+      title: issue.title,
+      body: issue.body,
+      state: issue.state.toUpperCase(),
+      author: issue.user ? { login: issue.user.login, avatarUrl: issue.user.avatar_url } : null,
+      labels: (issue.labels || []).map(l => typeof l === 'string' ? { name: l } : l),
+      createdAt: issue.created_at
+    };
+    ticketCache.set(cacheKey, { data, timestamp: Date.now() });
+    return data;
+  } catch (e) {
+    return null;
+  }
+}
+
+async function createTicket(repo, title, body, githubToken = null, projectConfig = null) {
+  const token = getToken(githubToken);
+  const org = projectConfig?.github_org || ORG;
+  const issue = await ghRest('POST', `/repos/${org}/${repo}/issues`, token, { title, body });
+  return { number: issue.number, url: issue.html_url, nodeId: issue.node_id };
+}
+
+async function addToProject(repo, issueNumber, githubToken = null, projectConfig = null) {
+  try {
+    const token = getToken(githubToken);
+    const org = projectConfig?.github_org || ORG;
+    const projectId = projectConfig?.github_project_id || config.PROJECT_ID;
+    const statusOptions = projectConfig?.status_options || config.STATUS_OPTIONS;
+
+    // Get issue node_id via REST
+    const issue = await ghRest('GET', `/repos/${org}/${repo}/issues/${issueNumber}`, token);
+    const contentId = issue.node_id;
+
+    // Add to project via GraphQL
+    const data = await ghGraphQL(
+      `mutation($projectId: ID!, $contentId: ID!) {
+        addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+          item { id }
+        }
+      }`,
+      { projectId, contentId },
+      token
+    );
+
+    const itemId = data.addProjectV2ItemById.item.id;
+
+    // Set status to Todo
+    const todoOptionId = statusOptions.TODO || statusOptions.todo;
+    await moveToStatus(itemId, todoOptionId, githubToken, projectConfig);
+    console.log(`Set issue #${issueNumber} to Todo status (item: ${itemId})`);
+
+    return true;
+  } catch (e) {
+    console.error('Failed to add to project:', e.message);
+    return false;
+  }
+}
+
+async function getIssueState(repo, issue, githubToken = null, projectConfig = null) {
+  try {
+    const token = getToken(githubToken);
+    const org = projectConfig?.github_org || ORG;
+    const data = await ghRest('GET', `/repos/${org}/${repo}/issues/${issue}`, token);
+    return data.state.toUpperCase();
+  } catch (e) {
+    return null;
+  }
+}
+
+async function reopenIssue(repo, issue, githubToken = null, projectConfig = null) {
+  const token = getToken(githubToken);
+  const org = projectConfig?.github_org || ORG;
+  await ghRest('PATCH', `/repos/${org}/${repo}/issues/${issue}`, token, { state: 'open' });
+}
+
+async function addComment(repo, issue, comment, githubToken = null, projectConfig = null) {
+  const token = getToken(githubToken);
+  const org = projectConfig?.github_org || ORG;
+  await ghRest('POST', `/repos/${org}/${repo}/issues/${issue}/comments`, token, { body: comment });
+}
+
+async function updateIssue(repo, issue, updates, githubToken = null, projectConfig = null) {
+  const token = getToken(githubToken);
+  const org = projectConfig?.github_org || ORG;
+  return await ghRest('PATCH', `/repos/${org}/${repo}/issues/${issue}`, token, updates);
+}
+
+async function getProjectItemId(repo, issue, githubToken = null, projectConfig = null) {
+  try {
+    const token = getToken(githubToken);
+    const org = projectConfig?.github_org || ORG;
+    const projectNumber = projectConfig?.project_number || config.PROJECT_NUMBER;
+    const data = await ghGraphQL(
+      `query {
+        organization(login: "${org}") {
+          projectV2(number: ${projectNumber}) {
+            items(first: 100, orderBy: {field: POSITION, direction: DESC}) {
+              nodes {
+                id
+                content {
+                  ... on Issue {
+                    number
+                    repository { name }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }`,
+      {},
+      token
+    );
+
+    const nodes = data.organization.projectV2.items.nodes;
+    const match = nodes.find(
+      n => n.content && n.content.number === issue && n.content.repository?.name === repo
+    );
+    return match ? match.id : null;
+  } catch (e) {
+    console.error('Failed to get project item ID:', e.message);
+    return null;
+  }
+}
+
+async function moveToStatus(itemId, statusOptionId, githubToken = null, projectConfig = null) {
+  try {
+    const token = getToken(githubToken);
+    const projectId = projectConfig?.github_project_id || config.PROJECT_ID;
+    const fieldId = projectConfig?.status_field_id || config.STATUS_FIELD_ID;
+    await ghGraphQL(
+      `mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+        updateProjectV2ItemFieldValue(input: {
+          projectId: $projectId
+          itemId: $itemId
+          fieldId: $fieldId
+          value: { singleSelectOptionId: $optionId }
+        }) {
+          projectV2Item { id }
+        }
+      }`,
+      {
+        projectId,
+        itemId,
+        fieldId,
+        optionId: statusOptionId
+      },
+      token
+    );
+    return true;
+  } catch (e) {
+    console.error('Failed to move status:', e.message);
+    return false;
+  }
+}
+
+// Per-project cache: Map<cacheKey, { data, timestamp }>
+const projectTicketCaches = new Map();
+const TRACKED_STATUSES = ['Todo', 'In Progress', 'test', 'Done'];
+
+async function fetchProjectTickets(projectConfig = null, githubToken = null, { claudeOnly = true } = {}) {
+  const org = projectConfig?.github_org || ORG;
+  const projectNumber = projectConfig?.project_number || config.PROJECT_NUMBER;
+  const cacheKey = `${org}/${projectNumber}`;
+  const cached = projectTicketCaches.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < 8000) {
+    return cached.data;
+  }
+
+  try {
+    const token = getToken(githubToken);
+    if (!token) return (cached && cached.data) || [];
+
+    const data = await ghGraphQL(
+      `query {
+        organization(login: "${org}") {
+          projectV2(number: ${projectNumber}) {
+            items(first: 100, orderBy: {field: POSITION, direction: DESC}) {
+              nodes {
+                id
+                fieldValueByName(name: "Status") {
+                  ... on ProjectV2ItemFieldSingleSelectValue { name }
+                }
+                content {
+                  ... on Issue {
+                    number
+                    title
+                    body
+                    state
+                    repository { name }
+                    author { login avatarUrl }
+                    createdAt
+                    comments(last: 50) {
+                      nodes { body author { login avatarUrl } createdAt }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }`,
+      {},
+      token
+    );
+
+    const nodes = data.organization.projectV2.items.nodes;
+    const tickets = nodes
+      .filter(n => {
+        const status = n.fieldValueByName?.name;
+        if (!status || !TRACKED_STATUSES.includes(status)) return false;
+        if (!n.content) return false;
+        if (claudeOnly) {
+          const bodyHasClaude = n.content.body?.includes('@claude');
+          const commentHasClaude = n.content.comments?.nodes?.some(c => c.body?.includes('@claude'));
+          if (!bodyHasClaude && !commentHasClaude) return false;
+        }
+        return true;
+      })
+      .map(n => {
+        const bodyHasClaude = n.content.body?.includes('@claude');
+        const commentHasClaude = n.content.comments?.nodes?.some(c => c.body?.includes('@claude'));
+        return {
+          projectItemId: n.id,
+          number: n.content.number,
+          repo: n.content.repository?.name,
+          title: n.content.title,
+          body: n.content.body || '',
+          state: n.content.state,
+          status: n.fieldValueByName.name,
+          author: n.content.author?.login,
+          authorAvatar: n.content.author?.avatarUrl,
+          createdAt: n.content.createdAt,
+          hasClaude: bodyHasClaude || commentHasClaude,
+          comments: (n.content.comments?.nodes || []).map(c => ({
+            body: c.body,
+            author: c.author?.login,
+            authorAvatar: c.author?.avatarUrl,
+            createdAt: c.createdAt
+          }))
+        };
+      });
+    projectTicketCaches.set(cacheKey, { data: tickets, timestamp: Date.now() });
+    return tickets;
+  } catch (e) {
+    console.error('Failed to fetch project tickets:', e.message);
+    return (cached && cached.data) || [];
+  }
+}
+
+function clearTicketCache() {
+  projectTicketCaches.clear();
+}
+
+module.exports = {
+  fetchTicketDetails,
+  createTicket,
+  addToProject,
+  getIssueState,
+  reopenIssue,
+  addComment,
+  updateIssue,
+  getProjectItemId,
+  moveToStatus,
+  fetchProjectTickets,
+  clearTicketCache,
+  setDefaultToken
+};

package/lib/history.js

@@ -0,0 +1,143 @@
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+
+let agentHistory = [];
+
+function loadHistory() {
+  try {
+    if (fs.existsSync(config.HISTORY_FILE)) {
+      agentHistory = JSON.parse(fs.readFileSync(config.HISTORY_FILE, 'utf8'));
+      console.log(`Loaded ${agentHistory.length} history entries`);
+    }
+  } catch (e) {
+    console.error('Error loading history:', e);
+    agentHistory = [];
+  }
+}
+
+function saveHistory() {
+  try {
+    fs.writeFileSync(config.HISTORY_FILE, JSON.stringify(agentHistory, null, 2));
+  } catch (e) {
+    console.error('Error saving history:', e);
+  }
+}
+
+function addToHistory(agent) {
+  const exists = agentHistory.find(a => a.id === agent.id);
+  if (exists) return;
+
+  agentHistory.unshift({
+    id: agent.id,
+    ticket: agent.ticket,
+    repo: agent.repo,
+    title: agent.title,
+    description: agent.description,
+    ticketStatus: agent.ticketStatus,
+    authorName: agent.authorName,
+    authorAvatar: agent.authorAvatar,
+    createdAt: agent.createdAt,
+    startTime: agent.startTime,
+    endTime: new Date().toISOString(),
+    completedAt: new Date().toLocaleString()
+  });
+
+  if (agentHistory.length > config.MAX_HISTORY) {
+    agentHistory = agentHistory.slice(0, config.MAX_HISTORY);
+  }
+
+  saveHistory();
+}
+
+function getHistory() {
+  return agentHistory;
+}
+
+function importExistingLogs() {
+  if (!fs.existsSync(config.AGENT_LOGS_DIR)) return;
+
+  const existingIds = new Set(agentHistory.map(a => a.id));
+  const locks = fs.existsSync('/tmp/auto-ticket-locks')
+    ? fs.readdirSync('/tmp/auto-ticket-locks').filter(f => f.startsWith('ticket-'))
+    : [];
+  const activeIds = new Set();
+
+  for (const lock of locks) {
+    try {
+      const agentId = fs.readFileSync(path.join('/tmp/auto-ticket-locks', lock), 'utf8').trim();
+      activeIds.add(agentId);
+    } catch(e) {}
+  }
+
+  const logFiles = fs.readdirSync(config.AGENT_LOGS_DIR)
+    .filter(f => f.endsWith('.log'))
+    .map(f => {
+      const filePath = path.join(config.AGENT_LOGS_DIR, f);
+      const stat = fs.statSync(filePath);
+      return { file: f, filePath, mtime: stat.mtime, birthtime: stat.birthtime };
+    })
+    .sort((a, b) => b.mtime - a.mtime);
+
+  let imported = 0;
+  for (const { file, filePath, mtime, birthtime } of logFiles) {
+    const agentId = file.replace('.log', '');
+
+    if (existingIds.has(agentId) || activeIds.has(agentId)) continue;
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf8').slice(0, 3000);
+      let ticket = null;
+      let title = null;
+      let repo = null;
+
+      const claimedMatch = content.match(/Claimed ticket #(\d+):\s*(.+?)(?:\n|$)/i);
+      if (claimedMatch) {
+        ticket = claimedMatch[1];
+        title = claimedMatch[2].trim().slice(0, 80);
+        if (claimedMatch[2].trim().length > 80) title += '...';
+      } else {
+        const ticketMatch = content.match(/ticket #(\d+)/i);
+        if (ticketMatch) ticket = ticketMatch[1];
+      }
+
+      const repoMatch = content.match(/\*?\*?Repo\*?\*?:\s*([\w_-]+)/i) || content.match(/-R data-tamer\/([\w_-]+)/i);
+      if (repoMatch) repo = repoMatch[1];
+      if (!repo) {
+        if (content.match(/tamer_service\//)) repo = 'tamer_service';
+        else if (content.match(/datatamer\.ai\//)) repo = 'datatamer.ai';
+        else if (content.match(/agentdev-webui\//)) repo = 'agentdev-webui';
+        else if (content.match(/agentdev-webui\//)) repo = 'agentdev-webui';
+        else repo = 'data-tamer-dashboard';
+      }
+
+      agentHistory.push({
+        id: agentId,
+        ticket,
+        repo,
+        title,
+        startTime: birthtime.toISOString(),
+        endTime: mtime.toISOString(),
+        completedAt: mtime.toLocaleString()
+      });
+      imported++;
+    } catch(e) {}
+  }
+
+  if (imported > 0) {
+    agentHistory.sort((a, b) => new Date(b.endTime || 0) - new Date(a.endTime || 0));
+    if (agentHistory.length > config.MAX_HISTORY) {
+      agentHistory = agentHistory.slice(0, config.MAX_HISTORY);
+    }
+    saveHistory();
+    console.log(`Imported ${imported} existing log files to history`);
+  }
+}
+
+module.exports = {
+  loadHistory,
+  saveHistory,
+  addToHistory,
+  getHistory,
+  importExistingLogs
+};

package/lib/pwa.js

@@ -0,0 +1,107 @@
+// PWA assets - version changes on server restart to trigger updates
+const SW_VERSION = Date.now();
+
+function getManifest() {
+  return {
+    name: 'Agent Dev',
+    short_name: 'AgentDev',
+    description: 'Multi-agent development workflow',
+    start_url: '/',
+    display: 'standalone',
+    orientation: 'portrait',
+    theme_color: '#1a1a2e',
+    background_color: '#1a1a2e',
+    icons: [
+      { src: '/icon-192.png', sizes: '192x192', type: 'image/png', purpose: 'any maskable' },
+      { src: '/icon-512.png', sizes: '512x512', type: 'image/png', purpose: 'any maskable' }
+    ]
+  };
+}
+
+function getServiceWorkerCode() {
+  return `
+const CACHE_NAME = 'autoticket-v${SW_VERSION}';
+const STATIC_ASSETS = ['/', '/manifest.json', '/icon-192.png', '/icon-512.png'];
+
+self.addEventListener('install', event => {
+  console.log('[SW] Installing new version:', CACHE_NAME);
+  event.waitUntil(
+    caches.open(CACHE_NAME).then(cache => cache.addAll(STATIC_ASSETS))
+  );
+  self.skipWaiting();
+});
+
+self.addEventListener('activate', event => {
+  console.log('[SW] Activating new version:', CACHE_NAME);
+  event.waitUntil(
+    caches.keys().then(keys => {
+      return Promise.all(
+        keys.filter(k => k.startsWith('autoticket-') && k !== CACHE_NAME)
+            .map(k => {
+              console.log('[SW] Deleting old cache:', k);
+              return caches.delete(k);
+            })
+      );
+    }).then(() => {
+      return self.clients.claim();
+    }).then(() => {
+      return self.clients.matchAll().then(clients => {
+        clients.forEach(client => client.postMessage({ type: 'SW_UPDATED' }));
+      });
+    })
+  );
+});
+
+self.addEventListener('fetch', event => {
+  if (event.request.url.includes('/logs')) return;
+  if (event.request.method !== 'GET') return;
+
+  if (event.request.mode === 'navigate' || (event.request.headers.get('accept') || '').includes('text/html')) {
+    event.respondWith(
+      fetch(event.request)
+        .then(response => {
+          const clone = response.clone();
+          caches.open(CACHE_NAME).then(cache => cache.put(event.request, clone));
+          return response;
+        })
+        .catch(() => caches.match(event.request))
+    );
+    return;
+  }
+
+  event.respondWith(
+    caches.match(event.request).then(cached => cached || fetch(event.request))
+  );
+});
+
+self.addEventListener('message', event => {
+  if (event.data && event.data.type === 'SKIP_WAITING') {
+    self.skipWaiting();
+  }
+});
+`;
+}
+
+function getIconSvg(size) {
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 100 100">
+  <rect width="100" height="100" rx="18.75" fill="#1a1a2e"/>
+  <path d="M50 18.75 L81.25 75 H18.75 Z" fill="none" stroke="#4ade80" stroke-width="7.8" stroke-linejoin="round"/>
+  <circle cx="50" cy="53.125" r="9.375" fill="#4ade80"/>
+</svg>`;
+}
+
+function getOgImageSvg() {
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="630" viewBox="0 0 1200 630">
+  <rect width="1200" height="630" fill="#1a1a2e"/>
+  <path d="M540 140 L680 400 H400 Z" fill="none" stroke="#4ade80" stroke-width="12" stroke-linejoin="round"/>
+  <circle cx="540" cy="300" r="18" fill="#4ade80"/>
+  <text x="600" y="520" font-family="system-ui,sans-serif" font-size="48" font-weight="bold" fill="#fff" text-anchor="middle">Agent Dev</text>
+</svg>`;
+}
+
+module.exports = {
+  getManifest,
+  getServiceWorkerCode,
+  getIconSvg,
+  getOgImageSvg
+};