openclaw-taskboard/server.js.backup

const express = require('express');
const path = require('path');
const fs = require('fs');
const http = require('http');
const sqlite3 = require('sqlite3').verbose();
const { WebSocketServer } = require('ws');

const PORT = process.env.PORT || 8395;
const DB_PATH = process.env.DB_PATH || path.join(__dirname, 'data', 'tasks.db');
const WIKI_DIR = process.env.WIKI_DIR || '/home/bear/.openclaw/workspace/wiki';

const AGENTS_DIR = process.env.AGENTS_DIR || '/home/bear/.openclaw/agents';
const OPENCLAW_CONFIG = process.env.OPENCLAW_CONFIG || '/home/bear/.openclaw/openclaw.json';
const VALID_STATUSES = ['Backlog', 'Todo', 'In Progress', 'Review', 'Done'];
const VALID_PRIORITIES = ['Low', 'Medium', 'High', 'Critical'];

fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
fs.mkdirSync(WIKI_DIR, { recursive: true });

const db = new sqlite3.Database(DB_PATH);

db.serialize(() => {
  db.run(`
    CREATE TABLE IF NOT EXISTS tasks (
      id INTEGER PRIMARY KEY AUTOINCREMENT,
      title TEXT NOT NULL,
      description TEXT DEFAULT '',
      assignee TEXT DEFAULT '',
      priority TEXT NOT NULL DEFAULT 'Medium',
      status TEXT NOT NULL DEFAULT 'Backlog',
      tags TEXT NOT NULL DEFAULT '[]',
      created_at TEXT NOT NULL DEFAULT (datetime('now')),
      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
      completed_at TEXT
    )
  `);
});

const app = express();
const server = http.createServer(app);
const wss = new WebSocketServer({ server });

app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));

function normalizeTask(row) {
  return {
    ...row,
    tags: (() => {
      try {
        return JSON.parse(row.tags || '[]');
      } catch {
        return [];
      }
    })(),
  };
}

function writeWiki(task) {
  const safeTitle = task.title
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, '-')
    .replace(/^-+|-+$/g, '')
    .slice(0, 80) || `task-${task.id}`;

  const fileName = `${new Date().toISOString().slice(0, 10)}-task-${task.id}-${safeTitle}.md`;
  const filePath = path.join(WIKI_DIR, fileName);

  const md = `# ${task.title}\n\n` +
    `- Task ID: ${task.id}\n` +
    `- Assignee: ${task.assignee || 'Unassigned'}\n` +
    `- Priority: ${task.priority}\n` +
    `- Status: ${task.status}\n` +
    `- Tags: ${task.tags.length ? task.tags.join(', ') : 'None'}\n` +
    `- Created: ${task.created_at}\n` +
    `- Completed: ${task.completed_at || new Date().toISOString()}\n\n` +
    `## Description\n\n${task.description || 'No description provided.'}\n`;

  fs.writeFileSync(filePath, md, 'utf8');
}

function broadcast(type, payload) {
  const data = JSON.stringify({ type, payload });
  for (const client of wss.clients) {
    if (client.readyState === 1) {
      client.send(data);
    }
  }
}

function validatePayload(body, partial = false) {
  const errors = [];

  if (!partial || body.title !== undefined) {
    if (typeof body.title !== 'string' || body.title.trim().length === 0) {
      errors.push('title is required');
    }
  }

  if (body.status !== undefined && !VALID_STATUSES.includes(body.status)) {
    errors.push(`status must be one of: ${VALID_STATUSES.join(', ')}`);
  }

  if (body.priority !== undefined && !VALID_PRIORITIES.includes(body.priority)) {
    errors.push(`priority must be one of: ${VALID_PRIORITIES.join(', ')}`);
  }

  if (body.tags !== undefined && !Array.isArray(body.tags)) {
    errors.push('tags must be an array of strings');
  }

  return errors;
}

app.get('/api/tasks', (req, res) => {
  db.all('SELECT * FROM tasks ORDER BY id DESC', (err, rows) => {
    if (err) {
      return res.status(500).json({ error: 'failed_to_fetch_tasks' });
    }

    return res.json(rows.map(normalizeTask));
  });
});

app.post('/api/tasks', (req, res) => {
  const errors = validatePayload(req.body, false);
  if (errors.length) {
    return res.status(400).json({ error: 'validation_error', details: errors });
  }

  const title = req.body.title.trim();
  const description = typeof req.body.description === 'string' ? req.body.description : '';
  const assignee = typeof req.body.assignee === 'string' ? req.body.assignee : '';
  const priority = req.body.priority || 'Medium';
  const status = req.body.status || 'Backlog';
  const tags = Array.isArray(req.body.tags) ? req.body.tags.filter((t) => typeof t === 'string') : [];

  db.run(
    `INSERT INTO tasks (title, description, assignee, priority, status, tags)
     VALUES (?, ?, ?, ?, ?, ?)`,
    [title, description, assignee, priority, status, JSON.stringify(tags)],
    function onInsert(err) {
      if (err) {
        return res.status(500).json({ error: 'failed_to_create_task' });
      }

      db.get('SELECT * FROM tasks WHERE id = ?', [this.lastID], (fetchErr, row) => {
        if (fetchErr || !row) {
          return res.status(500).json({ error: 'failed_to_fetch_created_task' });
        }

        const task = normalizeTask(row);
        broadcast('task_created', task);
        return res.status(201).json(task);
      });
    }
  );
});

app.patch('/api/tasks/:id', (req, res) => {
  const id = Number(req.params.id);
  if (!Number.isInteger(id) || id <= 0) {
    return res.status(400).json({ error: 'invalid_task_id' });
  }

  const errors = validatePayload(req.body, true);
  if (errors.length) {
    return res.status(400).json({ error: 'validation_error', details: errors });
  }

  db.get('SELECT * FROM tasks WHERE id = ?', [id], (err, existing) => {
    if (err) {
      return res.status(500).json({ error: 'failed_to_find_task' });
    }
    if (!existing) {
      return res.status(404).json({ error: 'task_not_found' });
    }

    const existingTask = normalizeTask(existing);
    const next = {
      title: req.body.title !== undefined ? req.body.title.trim() : existingTask.title,
      description: req.body.description !== undefined ? String(req.body.description) : existingTask.description,
      assignee: req.body.assignee !== undefined ? String(req.body.assignee) : existingTask.assignee,
      priority: req.body.priority !== undefined ? req.body.priority : existingTask.priority,
      status: req.body.status !== undefined ? req.body.status : existingTask.status,
      tags: req.body.tags !== undefined
        ? req.body.tags.filter((t) => typeof t === 'string')
        : existingTask.tags,
    };

    const nowDone = next.status === 'Done';
    const wasDone = existingTask.status === 'Done';
    const completedAt = nowDone && !wasDone
      ? new Date().toISOString()
      : nowDone
        ? existing.completed_at
        : null;

    db.run(
      `UPDATE tasks
       SET title = ?, description = ?, assignee = ?, priority = ?, status = ?, tags = ?,
           completed_at = ?, updated_at = datetime('now')
       WHERE id = ?`,
      [
        next.title,
        next.description,
        next.assignee,
        next.priority,
        next.status,
        JSON.stringify(next.tags),
        completedAt,
        id,
      ],
      (updateErr) => {
        if (updateErr) {
          return res.status(500).json({ error: 'failed_to_update_task' });
        }

        db.get('SELECT * FROM tasks WHERE id = ?', [id], (fetchErr, row) => {
          if (fetchErr || !row) {
            return res.status(500).json({ error: 'failed_to_fetch_updated_task' });
          }

          const task = normalizeTask(row);

          if (nowDone && !wasDone) {
            try {
              writeWiki(task);
            } catch (wikiErr) {
              console.error('wiki_creation_error', wikiErr);
            }
          }

          broadcast('task_updated', task);
          return res.json(task);
        });
      });
    });
  });

app.get('/api/agents', (req, res) => {
  try {
    const agents = [];
    
    if (fs.existsSync(AGENTS_DIR)) {
      const agentDirs = fs.readdirSync(AGENTS_DIR).filter(d => {
        return fs.statSync(path.join(AGENTS_DIR, d)).isDirectory();
      });

      agentDirs.forEach(agentName => {
        const agentPath = path.join(AGENTS_DIR, agentName);
        const workspacePath = path.join(agentPath, 'workspace');
        
        const agent = {
          name: agentName,
          status: 'active',
          currentTask: null,
          tools: [],
          files: [],
          permissions: []
        };

        if (fs.existsSync(workspacePath)) {
          const files = fs.readdirSync(workspacePath);
          agent.files = files.filter(f => f.endsWith('.md'));
          
          const memoryPath = path.join(workspacePath, 'MEMORY.md');
          if (fs.existsSync(memoryPath)) {
            const memory = fs.readFileSync(memoryPath, 'utf8');
            const toolMatches = memory.match(/##\\s+Tools([\\s\\S]*?)(?=##|$)/i);
            if (toolMatches) {
              agent.tools = toolMatches[1].split('\\n')
                .filter(line => line.trim().startsWith('-'))
                .map(line => line.replace(/^-\\s*/, '').trim());
            }
          }

          const heartbeatPath = path.join(workspacePath, 'HEARTBEAT.md');
          if (fs.existsSync(heartbeatPath)) {
            const heartbeat = fs.readFileSync(heartbeatPath, 'utf8');
            const taskMatch = heartbeat.match(/Current Task:\\s*(.+)/i);
            if (taskMatch) {
              agent.currentTask = taskMatch[1].trim();
            }
          }
        }

        agents.push(agent);
      });
    }

    res.json(agents);
  } catch (err) {
    console.error('Error reading agents:', err);
    res.status(500).json({ error: 'failed_to_fetch_agents' });
  }
});

// Usage endpoint
app.get('/api/usage', (req, res) => {
  try {
    const usage = {
      providers: [],
      lastUpdated: new Date().toISOString()
    };

    if (fs.existsSync(OPENCLAW_CONFIG)) {
      const config = JSON.parse(fs.readFileSync(OPENCLAW_CONFIG, 'utf8'));
      
      if (config.models) {
        const providerMap = {};
        
        Object.entries(config.models).forEach(([modelName, modelConfig]) => {
          const provider = modelConfig.provider || 'unknown';
          
          if (!providerMap[provider]) {
            providerMap[provider] = {
              name: provider,
              models: [],
              quota: {
                requests: 0,
                tokens: 0,
                limit: 'unlimited'
              }
            };
          }

          providerMap[provider].models.push({
            name: modelName,
            type: modelConfig.type || 'chat',
            contextWindow: modelConfig.context_window || 'unknown'
          });
        });

        usage.providers = Object.values(providerMap);
      }
    }

    res.json(usage);
  } catch (err) {
    console.error('Error reading usage:', err);
    res.status(500).json({ error: 'failed_to_fetch_usage' });
  }
});

// Heartbeat endpoint for agents
app.get('/api/heartbeat/:agent', (req, res) => {
  const agent = req.params.agent;
  
  db.all(
    'SELECT * FROM tasks WHERE assignee = ? AND status IN (?, ?, ?) ORDER BY priority DESC, created_at ASC',
    [agent, 'Todo', 'In Progress', 'Review'],
    (err, rows) => {
      if (err) {
        return res.status(500).json({ error: 'failed_to_fetch_tasks' });
      }

      const tasks = rows.map(normalizeTask);
      res.json({
        agent,
        pending_tasks: tasks.length,
        tasks
      });
    }
  );
});

wss.on('connection', (socket) => {
  socket.send(JSON.stringify({ type: 'connected', payload: { ok: true } }));
});

server.listen(PORT, '0.0.0.0', () => {
  console.log(`openclaw-taskboard listening on ${PORT}`);
});