@web42/stask 0.1.5

package/lib/session-tracker.mjs

@@ -0,0 +1,150 @@
+/**
+ * session-tracker.mjs — Session claim/release/status.
+ *
+ * Tracks which agent session is actively working on a task.
+ * Prevents multiple agent threads from colliding on the same task.
+ *
+ * Inspired by OpenClaw's KeyedAsyncQueue — serializes work per task key.
+ */
+
+import { getWorkspaceLibs, getPipelineConfig } from './env.mjs';
+
+const SESSION_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS active_sessions (
+  task_id     TEXT PRIMARY KEY REFERENCES tasks(task_id),
+  agent       TEXT NOT NULL,
+  session_id  TEXT NOT NULL,
+  claimed_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`;
+
+let _tableCreated = false;
+
+/**
+ * Ensure the active_sessions table exists.
+ */
+function ensureTable(db) {
+  if (_tableCreated) return;
+  db.exec(SESSION_TABLE_SQL);
+  _tableCreated = true;
+}
+
+/**
+ * Claim a task for an agent session.
+ * Fails if already claimed by a different session (unless stale).
+ *
+ * @returns {{ ok: boolean, message: string, claimedBy?: string }}
+ */
+export function claimTask(db, taskId, agent, sessionId) {
+  ensureTable(db);
+  const config = getPipelineConfig();
+  const staleMinutes = config.staleSessionMinutes || 30;
+
+  const existing = db.prepare('SELECT * FROM active_sessions WHERE task_id = ?').get(taskId);
+
+  if (existing) {
+    // Same session reclaiming — just refresh
+    if (existing.session_id === sessionId) {
+      db.prepare('UPDATE active_sessions SET claimed_at = datetime(\'now\') WHERE task_id = ?').run(taskId);
+      return { ok: true, message: `Refreshed claim on ${taskId}` };
+    }
+
+    // Check if stale
+    const claimedAt = new Date(existing.claimed_at + 'Z');
+    const ageMinutes = (Date.now() - claimedAt.getTime()) / 60000;
+
+    if (ageMinutes < staleMinutes) {
+      return {
+        ok: false,
+        message: `${taskId} is claimed by ${existing.agent} (session: ${existing.session_id}, ${Math.round(ageMinutes)}m ago). Still active.`,
+        claimedBy: existing.agent,
+      };
+    }
+
+    // Stale — reclaim
+    db.prepare('UPDATE active_sessions SET agent = ?, session_id = ?, claimed_at = datetime(\'now\') WHERE task_id = ?')
+      .run(agent, sessionId, taskId);
+    return { ok: true, message: `Reclaimed stale lock on ${taskId} (was ${existing.agent}, ${Math.round(ageMinutes)}m stale)` };
+  }
+
+  // No existing claim — create
+  db.prepare('INSERT INTO active_sessions (task_id, agent, session_id) VALUES (?, ?, ?)')
+    .run(taskId, agent, sessionId);
+  return { ok: true, message: `Claimed ${taskId} for ${agent}` };
+}
+
+/**
+ * Release a task session claim.
+ */
+export function releaseTask(db, taskId, sessionId = null) {
+  ensureTable(db);
+  if (sessionId) {
+    const result = db.prepare('DELETE FROM active_sessions WHERE task_id = ? AND session_id = ?')
+      .run(taskId, sessionId);
+    return result.changes > 0
+      ? { ok: true, message: `Released ${taskId}` }
+      : { ok: false, message: `${taskId} not claimed by session ${sessionId}` };
+  }
+  // Force release (no session check)
+  const result = db.prepare('DELETE FROM active_sessions WHERE task_id = ?').run(taskId);
+  return result.changes > 0
+    ? { ok: true, message: `Force-released ${taskId}` }
+    : { ok: false, message: `${taskId} has no active session` };
+}
+
+/**
+ * Get session status for a task (or all tasks).
+ */
+export function getSessionStatus(db, taskId = null) {
+  ensureTable(db);
+  const config = getPipelineConfig();
+  const staleMinutes = config.staleSessionMinutes || 30;
+
+  const rows = taskId
+    ? db.prepare('SELECT * FROM active_sessions WHERE task_id = ?').all(taskId)
+    : db.prepare('SELECT * FROM active_sessions ORDER BY claimed_at DESC').all();
+
+  return rows.map(row => {
+    const claimedAt = new Date(row.claimed_at + 'Z');
+    const ageMinutes = (Date.now() - claimedAt.getTime()) / 60000;
+    return {
+      ...row,
+      ageMinutes: Math.round(ageMinutes),
+      isStale: ageMinutes >= staleMinutes,
+    };
+  });
+}
+
+/**
+ * Check if a task is claimable by a given agent.
+ * Returns true if: no claim, same agent, or stale.
+ */
+export function isTaskClaimable(db, taskId, agent) {
+  ensureTable(db);
+  const config = getPipelineConfig();
+  const staleMinutes = config.staleSessionMinutes || 30;
+
+  const existing = db.prepare('SELECT * FROM active_sessions WHERE task_id = ?').get(taskId);
+  if (!existing) return true;
+  if (existing.agent === agent) return true;
+
+  const claimedAt = new Date(existing.claimed_at + 'Z');
+  const ageMinutes = (Date.now() - claimedAt.getTime()) / 60000;
+  return ageMinutes >= staleMinutes;
+}
+
+/**
+ * Clean up stale sessions (run periodically).
+ */
+export function cleanStaleSessions(db) {
+  ensureTable(db);
+  const config = getPipelineConfig();
+  const staleMinutes = config.staleSessionMinutes || 30;
+
+  const result = db.prepare(`
+    DELETE FROM active_sessions
+    WHERE (julianday('now') - julianday(claimed_at)) * 24 * 60 >= ?
+  `).run(staleMinutes);
+
+  return result.changes;
+}

package/lib/slack-api.mjs

@@ -0,0 +1,198 @@
+/**
+ * slack-api.mjs — Slack API helpers shared across sync scripts.
+ */
+
+import https from 'https';
+import fs from 'fs';
+
+// Slack token loaded from env by stask's env.mjs (loadEnv populates process.env)
+const config = {
+  get slackToken() { return process.env.SLACK_TOKEN; },
+  logFile: null,
+};
+
+/**
+ * Logger with optional file output.
+ */
+export const logger = {
+  info: (msg) => log('INFO', msg),
+  error: (msg) => log('ERROR', msg),
+  warn: (msg) => log('WARN', msg),
+  debug: (msg) => log('DEBUG', msg),
+};
+
+function log(level, msg) {
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] [${level}] ${msg}`;
+  console.error(line);
+  if (config.logFile) {
+    fs.appendFileSync(config.logFile, line + '\n');
+  }
+}
+
+/**
+ * JSON POST to Slack API.
+ */
+export async function slackApiRequest(method, endpoint, data) {
+  return new Promise((resolve, reject) => {
+    const reqData = JSON.stringify(data);
+    const req = https.request(new URL(`https://slack.com/api${endpoint}`), {
+      method,
+      headers: {
+        'Authorization': `Bearer ${config.slackToken}`,
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Length': Buffer.byteLength(reqData),
+      },
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(body);
+          if (!json.ok) {
+            reject(new Error(`Slack API error: ${json.error} (${json.detail || json.response_metadata?.messages?.join('; ') || 'no detail'})`));
+          } else {
+            resolve(json);
+          }
+        } catch (e) {
+          reject(new Error(`Failed to parse Slack response: ${e.message}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Slack API request timeout')); });
+    req.setTimeout(15000);
+    req.write(reqData);
+    req.end();
+  });
+}
+
+/**
+ * Form-urlencoded POST to Slack API (required by files.* endpoints).
+ */
+export async function slackFormRequest(endpoint, params) {
+  return new Promise((resolve, reject) => {
+    const formData = Object.entries(params)
+      .map(([k, v]) => k + '=' + encodeURIComponent(v))
+      .join('&');
+    const req = https.request(new URL(`https://slack.com/api${endpoint}`), {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${config.slackToken}`,
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': Buffer.byteLength(formData),
+      },
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(body);
+          if (!json.ok) reject(new Error(`Slack API error: ${json.error}`));
+          else resolve(json);
+        } catch (e) { reject(new Error(`Failed to parse response: ${e.message}`)); }
+      });
+    });
+    req.on('error', reject);
+    req.setTimeout(15000);
+    req.write(formData);
+    req.end();
+  });
+}
+
+/**
+ * POST raw content to a Slack upload URL.
+ */
+export async function uploadToUrl(uploadUrl, content, contentType = 'text/markdown') {
+  return new Promise((resolve, reject) => {
+    const url = new URL(uploadUrl);
+    const req = https.request({
+      hostname: url.hostname,
+      path: url.pathname + url.search,
+      method: 'POST',
+      headers: { 'Content-Type': contentType, 'Content-Length': Buffer.byteLength(content) },
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) resolve(body);
+        else reject(new Error(`Upload failed: HTTP ${res.statusCode}`));
+      });
+    });
+    req.on('error', reject);
+    req.setTimeout(30000);
+    req.write(content);
+    req.end();
+  });
+}
+
+/**
+ * 3-step file upload: getUploadURL → upload content → complete.
+ * Returns the Slack file ID.
+ * @param {string} filename
+ * @param {Buffer|string} content
+ * @param {string} [contentType] - MIME type (default: text/markdown, auto-detects for common extensions)
+ */
+export async function uploadFile(filename, content, contentType) {
+  const buf = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf-8');
+  if (!contentType) {
+    const ext = filename.split('.').pop()?.toLowerCase();
+    contentType = { zip: 'application/zip', png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif' }[ext] || 'text/markdown';
+  }
+  const urlResp = await slackFormRequest('/files.getUploadURLExternal', {
+    filename,
+    length: buf.length,
+  });
+  await uploadToUrl(urlResp.upload_url, buf, contentType);
+  await slackApiRequest('POST', '/files.completeUploadExternal', {
+    files: [{ id: urlResp.file_id, title: filename }],
+  });
+  return urlResp.file_id;
+}
+
+/**
+ * Get all rows from a Slack List (with pagination).
+ */
+export async function getListItems(listId, limit = 100) {
+  const allItems = [];
+  let cursor = null;
+  while (true) {
+    const payload = { list_id: listId, limit };
+    if (cursor) payload.cursor = cursor;
+    const result = await slackApiRequest('POST', '/slackLists.items.list', payload);
+    allItems.push(...(result.items || []));
+    cursor = result.response_metadata?.next_cursor;
+    if (!cursor) break;
+  }
+  return allItems;
+}
+
+/**
+ * Create a new row in a Slack List.
+ * @param {string} parentItemId - Optional parent row ID for native subtasks
+ */
+export async function createListRow(listId, initialFields, parentItemId = null) {
+  const payload = { list_id: listId, initial_fields: initialFields };
+  if (parentItemId) payload.parent_item_id = parentItemId;
+  return slackApiRequest('POST', '/slackLists.items.create', payload);
+}
+
+/**
+ * Update cells in existing Slack List rows (batch).
+ */
+export async function updateListCells(listId, cells) {
+  return slackApiRequest('POST', '/slackLists.items.update', {
+    list_id: listId,
+    cells,
+  });
+}
+
+/**
+ * Delete a row from a Slack List.
+ */
+export async function deleteListRow(listId, itemId) {
+  return slackApiRequest('POST', '/slackLists.items.delete', {
+    list_id: listId,
+    id: itemId,
+  });
+}

package/lib/slack-row.mjs

@@ -0,0 +1,257 @@
+/**
+ * slack-row.mjs — Targeted per-row Slack List sync.
+ *
+ * All Slack column IDs, select option IDs, and user IDs come from config.json.
+ * Row ID mappings are cached in the slack_row_ids table in tracker.db.
+ */
+
+import { CONFIG, getWorkspaceLibs } from './env.mjs';
+import { getSlackUserId } from './roles.mjs';
+import * as trackerDb from './tracker-db.mjs';
+
+const SLACK = CONFIG.slack;
+const COLS = SLACK.columns;
+
+// ─── Ensure slack_row_ids table ────────────────────────────────────
+
+const ROW_IDS_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS slack_row_ids (
+  task_id  TEXT PRIMARY KEY REFERENCES tasks(task_id),
+  row_id   TEXT NOT NULL
+);
+`;
+
+let _rowTableCreated = false;
+
+function ensureRowIdsTable(db) {
+  if (_rowTableCreated) return;
+  db.exec(ROW_IDS_TABLE_SQL);
+  _rowTableCreated = true;
+}
+
+// ─── Local row ID cache ────────────────────────────────────────────
+
+export function getSlackRowId(db, taskId) {
+  ensureRowIdsTable(db);
+  const row = db.prepare('SELECT row_id FROM slack_row_ids WHERE task_id = ?').get(taskId);
+  return row?.row_id || null;
+}
+
+function setSlackRowId(db, taskId, rowId) {
+  ensureRowIdsTable(db);
+  db.prepare(`
+    INSERT INTO slack_row_ids (task_id, row_id) VALUES (?, ?)
+    ON CONFLICT(task_id) DO UPDATE SET row_id = excluded.row_id
+  `).run(taskId, rowId);
+}
+
+// ─── Cell formatting (config-driven) ───────────────────────────────
+
+function formatCell(fieldName, value, columnId, taskRow) {
+  if (!value || value === 'N/A' || value === 'None' || String(value).trim() === '') return null;
+  const v = String(value).trim();
+
+  // Status → select
+  if (fieldName === 'Status') {
+    const optId = SLACK.statusOptions[v];
+    if (optId) return { column_id: columnId, select: [optId] };
+    return null;
+  }
+
+  // Type → select
+  if (fieldName === 'Type') {
+    const optId = SLACK.typeOptions?.[v];
+    if (optId) return { column_id: columnId, select: [optId] };
+    return null;
+  }
+
+  // Assigned To → user (respects DB value, no status override)
+  if (fieldName === 'Assigned To') {
+    const userId = getSlackUserId(v);
+    if (userId) return { column_id: columnId, user: [userId] };
+    return null;
+  }
+
+  // Spec → attachment
+  if (fieldName === 'Spec') {
+    if (v === 'TBD') return null;
+    const m = v.match(/^(.+?)\s*\((\w+)\)$/);
+    const fileId = m ? m[2] : null;
+    if (!fileId) return null;
+    return { column_id: columnId, attachment: [fileId] };
+  }
+
+  // QA Reports → attachment(s)
+  if (fieldName.startsWith('QA Report')) {
+    const ids = [...v.matchAll(/\((\w+)\)/g)].map(m => m[1]);
+    if (ids.length === 0) return null;
+    return { column_id: columnId, attachment: ids };
+  }
+
+  // PR → link
+  if (fieldName === 'PR') {
+    return { column_id: columnId, link: [{ original_url: v }] };
+  }
+
+  // PR Status → attachment (pr-status/{taskId}.md with file ID)
+  if (fieldName === 'PR Status') {
+    const m = v.match(/^(.+?)\s*\((\w+)\)$/);
+    const fileId = m ? m[2] : null;
+    if (!fileId) return null;
+    return { column_id: columnId, attachment: [fileId] };
+  }
+
+  // Default → rich_text
+  return {
+    column_id: columnId,
+    rich_text: [{
+      type: 'rich_text',
+      elements: [{ type: 'rich_text_section', elements: [{ type: 'text', text: v }] }],
+    }],
+  };
+}
+
+/**
+ * Build cell array for a task row.
+ * Returns { coreCells, attachmentCells, allCells }.
+ */
+function buildCells(taskRow) {
+  const FIELD_MAP = {
+    'Task ID':     COLS.task_id,
+    'Task Name':   COLS.name,
+    'Status':      COLS.status,
+    'Assigned To': COLS.assignee,
+    'Spec':        COLS.spec,
+    'QA Report 1': COLS.qa_report_1,
+    'QA Report 2': COLS.qa_report_2,
+    'QA Report 3': COLS.qa_report_3,
+    'Type':        COLS.type,
+    'Worktree':    COLS.worktree,
+    'PR':          COLS.pr,
+    'PR Status':   COLS.pr_status,
+  };
+
+  const allCells = [];
+  for (const [field, colId] of Object.entries(FIELD_MAP)) {
+    if (!colId) continue;
+    const cell = formatCell(field, taskRow[field], colId, taskRow);
+    if (cell) allCells.push(cell);
+  }
+
+  // Checkbox for Done status
+  allCells.push({ column_id: COLS.completed, checkbox: taskRow['Status'] === 'Done' });
+
+  return {
+    allCells,
+    coreCells: allCells.filter(c => !c.attachment),
+    attachmentCells: allCells.filter(c => c.attachment),
+  };
+}
+
+// ─── Public sync operations ────────────────────────────────────────
+
+/**
+ * Sync a task row to Slack: create if new, update if existing.
+ * Uses slack_row_ids table for fast lookup (no full list scan).
+ *
+ * @param {Object} db - SQLite database handle
+ * @param {Object} taskRow - Task object (from tracker-db rowToTask)
+ * @param {string|null} parentSlackRowId - Parent Slack row ID (for subtasks)
+ * @returns {{ action, rowId, slackOps[] }}
+ */
+export async function syncTaskToSlack(db, taskRow, parentSlackRowId = null) {
+  const libs = await getWorkspaceLibs();
+  const { createListRow, updateListCells } = libs.slackApi;
+  const listId = SLACK.listId;
+  const { coreCells, attachmentCells } = buildCells(taskRow);
+  const slackOps = [];
+
+  const existingRowId = getSlackRowId(db, taskRow['Task ID']);
+
+  if (existingRowId) {
+    // Update existing row
+    const coreWithRow = coreCells.map(c => ({ row_id: existingRowId, ...c }));
+    const attachWithRow = attachmentCells.map(c => ({ row_id: existingRowId, ...c }));
+
+    if (coreWithRow.length > 0) {
+      await updateListCells(listId, coreWithRow);
+      slackOps.push({ type: 'update', rowId: existingRowId, cells: coreWithRow });
+    }
+    for (const cell of attachWithRow) {
+      await updateListCells(listId, [cell]);
+      slackOps.push({ type: 'update', rowId: existingRowId, cells: [cell] });
+    }
+    // Record sync state: mark current time as Slack ts to prevent pull-back
+    recordSyncState(taskRow);
+    return { action: 'updated', rowId: existingRowId, slackOps };
+  }
+
+  // Create new row
+  const result = await createListRow(listId, coreCells, parentSlackRowId);
+  const rowId = result.item?.id;
+  if (!rowId) throw new Error(`Slack createListRow returned no item ID for ${taskRow['Task ID']}`);
+
+  slackOps.push({ type: 'create', rowId });
+  setSlackRowId(db, taskRow['Task ID'], rowId);
+
+  // Attachments require separate update after create
+  if (attachmentCells.length > 0) {
+    for (const cell of attachmentCells) {
+      await updateListCells(listId, [{ row_id: rowId, ...cell }]);
+      slackOps.push({ type: 'update', rowId, cells: [{ row_id: rowId, ...cell }] });
+    }
+  }
+
+  // Record sync state for new rows too
+  recordSyncState(taskRow);
+  return { action: 'created', rowId, slackOps };
+}
+
+/**
+ * Sync a subtask row to Slack. Resolves parent row ID from slack_row_ids.
+ */
+export async function syncSubtaskToSlack(db, subtaskRow) {
+  const parentId = subtaskRow['Parent'];
+  if (!parentId || parentId === 'None') {
+    throw new Error(`Subtask ${subtaskRow['Task ID']} has no parent`);
+  }
+
+  const parentRowId = getSlackRowId(db, parentId);
+  if (!parentRowId) {
+    throw new Error(`Parent ${parentId} has no Slack row ID. Sync the parent first.`);
+  }
+
+  return syncTaskToSlack(db, subtaskRow, parentRowId);
+}
+
+/**
+ * Record sync state after pushing to Slack.
+ * Uses current Unix time as Slack timestamp (approximation — the actual
+ * Slack updated_timestamp will be >= this value, so the daemon won't
+ * see it as a Slack-side change).
+ */
+function recordSyncState(taskRow) {
+  try {
+    const nowUnix = Math.floor(Date.now() / 1000);
+    const dbTs = taskRow['updated_at'] || new Date().toISOString().replace('T', ' ').slice(0, 19);
+    trackerDb.setSyncState(taskRow['Task ID'], nowUnix, dbTs);
+  } catch (_err) {
+    // Non-fatal — sync daemon will handle on next cycle
+  }
+}
+
+/**
+ * Delete a Slack row by task ID.
+ */
+export async function deleteSlackRow(db, taskId) {
+  const libs = await getWorkspaceLibs();
+  const { deleteListRow } = libs.slackApi;
+  const listId = SLACK.listId;
+
+  const rowId = getSlackRowId(db, taskId);
+  if (!rowId) return { action: 'noop', slackOps: [] };
+
+  await deleteListRow(listId, rowId);
+  db.prepare('DELETE FROM slack_row_ids WHERE task_id = ?').run(taskId);
+  return { action: 'deleted', rowId, slackOps: [{ type: 'delete', rowId }] };
+}