amalgm 0.0.0 → 0.0.32

package/runtime/scripts/amalgm-mcp/tasks/executor.js

@@ -0,0 +1,225 @@
+/**
+ * Task executor — runs a task through the local chat-server.
+ *
+ * On each run:
+ *   1. Allocate a fresh runId + codeSessionId + message IDs.
+ *   2. (Optional) Create a Supabase session row so the run shows up in the UI.
+ *   3. POST to chat-server /chat and consume the SSE stream.
+ *   4. Append a run-log JSONL entry and update task metadata.
+ *
+ * Held state (runningTasks) is purely in-process — it tracks abort controllers
+ * so MCP's scheduled_tasks_cancel can abort a live run.
+ */
+
+const crypto = require('crypto');
+const os = require('os');
+
+const { AMALGM_COMPUTER_ID, AMALGM_USER_ID, DEFAULT_CWD } = require('../config');
+const { runThroughChatServer } = require('../lib/chat-runner');
+const { hasSupabase, supabaseInsert, supabasePatch } = require('../lib/supabase');
+const { appendRunLog, updateTaskMeta } = require('./store');
+const {
+  chatInputToLegacyFields,
+  normalizeChatInput,
+} = require('../../../lib/chatInput');
+const { DEFAULT_SELECTED_MODELS, resolveModelSelection } = require('../lib/prefs');
+const credentialAdapter = require('../../credential-adapter');
+const { buildLocalMcpServerConfigs } = require('../lib/mcp-resolver');
+
+const runningTasks = new Map(); // taskId → { runId, abortController, codeSessionId }
+
+function harnessToAgent(harness) {
+  const map = { claude_code: 'claude', codex: 'codex', opencode: 'opencode', pi: 'pi', amp: 'amp', cursor: 'cursor' };
+  return map[harness] || 'claude';
+}
+
+function isRunning(taskId) {
+  return runningTasks.has(taskId);
+}
+
+function getRunning(taskId) {
+  return runningTasks.get(taskId) || null;
+}
+
+function abortRunning(taskId) {
+  const running = runningTasks.get(taskId);
+  if (running) {
+    running.abortController.abort();
+    return running;
+  }
+  return null;
+}
+
+function disableTerminalScheduleIfNeeded(task) {
+  if (task.schedule.kind === 'once') {
+    updateTaskMeta(task.id, { enabled: false });
+    return;
+  }
+  if (task.endsAt && new Date(task.endsAt) <= new Date()) {
+    updateTaskMeta(task.id, { enabled: false });
+  }
+}
+
+function resolveTaskRequest(task) {
+  const harness =
+    (task.chatInput && task.chatInput.agent && task.chatInput.agent.harness)
+    || task.harness
+    || 'claude_code';
+  const model =
+    (task.chatInput && task.chatInput.agent && task.chatInput.agent.model)
+    || task.model
+    || DEFAULT_SELECTED_MODELS[harness]
+    || null;
+  const authMethod =
+    (task.chatInput && task.chatInput.agent && task.chatInput.agent.authMethod)
+    || task.authMethod
+    || (credentialAdapter.VALID_HARNESS_IDS.includes(harness)
+      ? credentialAdapter.getPersistedAuthMode(harness)
+      : 'amalgm');
+  const chatInput = normalizeChatInput(task.chatInput, {
+    prompt: task.prompt,
+    harness,
+    modelId: model,
+    authMethod,
+    cwd: task.projectPath,
+    projectPath: task.projectPath,
+  });
+  const legacy = chatInputToLegacyFields(chatInput, {
+    prompt: task.prompt,
+    harness,
+    modelId: model,
+    authMethod,
+    cwd: task.projectPath,
+    projectPath: task.projectPath,
+  });
+  const modelSelection = resolveModelSelection(harness, legacy.modelId || model);
+
+  return {
+    harness,
+    chatInput,
+    legacy,
+    modelSelection,
+  };
+}
+
+async function executeTask(task) {
+  const runId = crypto.randomUUID();
+  const startedAt = new Date().toISOString();
+  const { harness, chatInput, legacy, modelSelection } = resolveTaskRequest(task);
+  const mcpServers = await buildLocalMcpServerConfigs(legacy.mcpAppIds || []);
+
+  console.log(`[AmalgmMCP:Exec] Starting task ${task.id} (${task.name}), run ${runId}`);
+  appendRunLog(task.id, { runId, startedAt, status: 'running', prompt: task.prompt });
+  updateTaskMeta(task.id, { lastRunAt: startedAt, lastStatus: 'running' });
+
+  const codeSessionId = crypto.randomUUID();
+  const userMessageId = crypto.randomUUID();
+  const assistantMessageId = crypto.randomUUID();
+
+  if (hasSupabase()) {
+    try {
+      await supabaseInsert('sessions', {
+        id: codeSessionId,
+        user_id: AMALGM_USER_ID,
+        computer_id: AMALGM_COMPUTER_ID,
+        container_id: os.hostname() || 'task-execution',
+        harness,
+        title: 'New Chat',
+        origin: 'task',
+        origin_id: task.id,
+        project_path: legacy.cwd || task.projectPath || null,
+        status: 'in-progress',
+        metadata: { taskRunId: runId, automated: true, originName: task.name },
+      });
+    } catch (err) {
+      console.error('[AmalgmMCP:Exec] DB session creation failed:', err.message);
+    }
+  }
+
+  appendRunLog(task.id, { runId, sessionId: codeSessionId, type: 'session_created' });
+
+  const abortController = new AbortController();
+  runningTasks.set(task.id, { runId, abortController, codeSessionId });
+
+  try {
+    const { outputText, stopReason } = await runThroughChatServer(
+      {
+        chatInput,
+        prompt: legacy.prompt,
+        userId: AMALGM_USER_ID,
+        codeSessionId,
+        computerId: AMALGM_COMPUTER_ID,
+        assistantMessageId,
+        userMessageId,
+        agentId: harnessToAgent(harness),
+        userParts: legacy.userParts,
+        modelId: modelSelection.modelId || legacy.modelId || null,
+        cliModel: modelSelection.cliModel || null,
+        ...(modelSelection.reasoningEffort ? { reasoningEffort: modelSelection.reasoningEffort } : {}),
+        cwd: legacy.cwd || DEFAULT_CWD,
+        authMethod: legacy.authMethod || null,
+        mcpServers,
+        taskId: task.id,
+        automated: true,
+      },
+      abortController.signal,
+    );
+
+    const finishedAt = new Date().toISOString();
+    const durationMs = Date.now() - new Date(startedAt).getTime();
+    const status = 'completed';
+
+    appendRunLog(task.id, {
+      runId,
+      finishedAt,
+      status,
+      durationMs,
+      sessionId: codeSessionId,
+      stopReason: stopReason || null,
+      outputLength: outputText.length,
+    });
+    updateTaskMeta(task.id, { lastStatus: status });
+    disableTerminalScheduleIfNeeded(task);
+
+    console.log(
+      `[AmalgmMCP:Exec] Task ${task.id} ${status} in ${durationMs}ms (session: ${codeSessionId})`,
+    );
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      appendRunLog(task.id, {
+        runId,
+        finishedAt: new Date().toISOString(),
+        status: 'cancelled',
+      });
+      updateTaskMeta(task.id, { lastStatus: 'cancelled' });
+      disableTerminalScheduleIfNeeded(task);
+    } else {
+      appendRunLog(task.id, {
+        runId,
+        finishedAt: new Date().toISOString(),
+        status: 'failed',
+        error: err.message,
+      });
+      updateTaskMeta(task.id, { lastStatus: 'failed' });
+      disableTerminalScheduleIfNeeded(task);
+      console.error(`[AmalgmMCP:Exec] Task ${task.id} failed:`, err.message);
+    }
+    if (hasSupabase()) {
+      supabasePatch('sessions', 'id', codeSessionId, {
+        last_message_at: new Date().toISOString(),
+        status: 'error',
+        new_messages: true,
+        metadata: {
+          taskRunId: runId,
+          automated: true,
+          originName: task.name,
+          error: err.message || 'cancelled',
+        },
+      }).catch(() => {});
+    }
+  } finally {
+    runningTasks.delete(task.id);
+  }
+}
+
+module.exports = { executeTask, isRunning, getRunning, abortRunning };

package/runtime/scripts/amalgm-mcp/tasks/rest.js

@@ -0,0 +1,110 @@
+/**
+ * /tasks/* REST routes for the Next.js API to call.
+ * Not part of the MCP tool surface — used by the internal UI.
+ */
+
+const { loadTasks } = require('./store');
+const taskTools = require('./tools');
+
+const taskToolHandlers = new Map(taskTools.map((tool) => [tool.name, tool.handler]));
+
+function extractText(result) {
+  const entry = Array.isArray(result?.content)
+    ? result.content.find((item) => item && item.type === 'text' && typeof item.text === 'string')
+    : null;
+  return entry?.text || '';
+}
+
+function parseTaskFromText(text) {
+  const jsonStart = typeof text === 'string' ? text.indexOf('{') : -1;
+  if (jsonStart < 0) return null;
+
+  try {
+    return JSON.parse(text.slice(jsonStart));
+  } catch {
+    return null;
+  }
+}
+
+async function callTaskTool(name, args) {
+  const handler = taskToolHandlers.get(name);
+  if (!handler) {
+    throw new Error(`Unknown task tool: ${name}`);
+  }
+
+  const result = await handler(args);
+  const text = extractText(result);
+  return {
+    result,
+    text,
+    isError: Boolean(result?.isError),
+  };
+}
+
+async function handleList(sendJson) {
+  const data = loadTasks();
+  sendJson(200, { tasks: data?.tasks || [] });
+}
+
+async function handleCreate(body, sendJson) {
+  const response = await callTaskTool('scheduled_tasks_create', body);
+  if (response.isError) {
+    return sendJson(400, { error: response.text || 'Failed to create task' });
+  }
+
+  sendJson(200, {
+    ok: true,
+    task: parseTaskFromText(response.text),
+    output: response.result,
+  });
+}
+
+async function handleUpdate(body, sendJson) {
+  const response = await callTaskTool('scheduled_tasks_update', body);
+  if (response.isError) {
+    const status = response.text.startsWith('Task not found:') ? 404 : 400;
+    return sendJson(status, { error: response.text || 'Failed to update task' });
+  }
+
+  sendJson(200, {
+    ok: true,
+    task: parseTaskFromText(response.text),
+    output: response.result,
+  });
+}
+
+async function handleDelete(body, sendJson) {
+  const response = await callTaskTool('scheduled_tasks_delete', body);
+  if (response.isError) {
+    const status = response.text.startsWith('Task not found:') ? 404 : 400;
+    return sendJson(status, { error: response.text || 'Failed to delete task' });
+  }
+
+  sendJson(200, {
+    ok: true,
+    message: response.text,
+    output: response.result,
+  });
+}
+
+async function handleRunNow(body, sendJson) {
+  const response = await callTaskTool('scheduled_tasks_run_now', body);
+  if (response.isError) {
+    const status = response.text.startsWith('Task not found:') ? 404 : 400;
+    return sendJson(status, { error: response.text || 'Failed to run task' });
+  }
+
+  sendJson(200, {
+    ok: true,
+    message: response.text,
+    output: response.result,
+  });
+}
+
+module.exports = {
+  handleList,
+  handleCreate,
+  handleUpdate,
+  handleDelete,
+  handleRunNow,
+};

package/runtime/scripts/amalgm-mcp/tasks/schedule-normalization.js

@@ -0,0 +1,85 @@
+/**
+ * Task schedule normalization helpers.
+ *
+ * - One-shot tasks are stored as UTC timestamps.
+ * - Recurring cron tasks always carry an explicit IANA timezone.
+ * - Interval tasks are stored as validated millisecond values.
+ */
+
+function getDefaultScheduleTimeZone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+  } catch {
+    return 'UTC';
+  }
+}
+
+function normalizeOnceAt(at) {
+  if (typeof at !== 'string' || !at.trim()) return null;
+  const parsed = new Date(at.trim());
+  if (Number.isNaN(parsed.getTime())) return null;
+  return parsed.toISOString();
+}
+
+function normalizeTaskSchedule(schedule, { fallbackTimeZone = getDefaultScheduleTimeZone() } = {}) {
+  if (!schedule || typeof schedule !== 'object') {
+    return { schedule: null, error: 'schedule is required' };
+  }
+
+  if (schedule.kind === 'cron') {
+    if (!schedule.expr || typeof schedule.expr !== 'string') {
+      return { schedule: null, error: 'cron schedule requires "expr" field' };
+    }
+
+    return {
+      schedule: {
+        kind: 'cron',
+        expr: schedule.expr.trim(),
+        tz: typeof schedule.tz === 'string' && schedule.tz.trim()
+          ? schedule.tz.trim()
+          : fallbackTimeZone,
+      },
+      error: null,
+    };
+  }
+
+  if (schedule.kind === 'once') {
+    const at = normalizeOnceAt(schedule.at);
+    if (!at) {
+      return { schedule: null, error: 'once schedule requires a valid ISO datetime in "at"' };
+    }
+
+    return {
+      schedule: {
+        kind: 'once',
+        at,
+      },
+      error: null,
+    };
+  }
+
+  if (schedule.kind === 'interval') {
+    const ms = Number(schedule.ms);
+    if (!Number.isFinite(ms) || ms < 60_000) {
+      return { schedule: null, error: 'interval requires "ms" field (min 60000)' };
+    }
+
+    return {
+      schedule: {
+        kind: 'interval',
+        ms,
+      },
+      error: null,
+    };
+  }
+
+  return {
+    schedule: null,
+    error: `Unsupported schedule kind: ${String(schedule.kind)}`,
+  };
+}
+
+module.exports = {
+  getDefaultScheduleTimeZone,
+  normalizeTaskSchedule,
+};

package/runtime/scripts/amalgm-mcp/tasks/scheduler.js

@@ -0,0 +1,105 @@
+/**
+ * Task scheduler — 30s poll loop.
+ *
+ * Checks every enabled task each tick; if it's due and not already running,
+ * kicks off an execution via tasks/executor.js. Scheduler is stateless;
+ * currently-running tasks live in executor.js's `runningTasks` map.
+ */
+
+const { SCHEDULER_INTERVAL_MS } = require('../config');
+const { loadTasks } = require('./store');
+const { executeTask, isRunning } = require('./executor');
+const { loadCronParser } = require('../deps');
+
+let schedulerTimer = null;
+let _cronParser = null;
+
+function cron() {
+  if (!_cronParser) _cronParser = loadCronParser();
+  return _cronParser;
+}
+
+/**
+ * Validate a cron expression + timezone. Returns null on success, error
+ * message on failure.
+ */
+function validateCronExpr(expr, tz) {
+  try {
+    cron().CronExpressionParser.parse(expr, { tz: tz || 'UTC' });
+    return null;
+  } catch (e) {
+    return e.message;
+  }
+}
+
+function validDate(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+/**
+ * Is the given task due to run right now?
+ */
+function isTaskDue(task, now) {
+  if (!task.enabled) return false;
+  if (task.endsAt && new Date(task.endsAt) < now) return false;
+
+  const schedule = task.schedule;
+  if (schedule.kind === 'once') {
+    const runAt = new Date(schedule.at);
+    if (Number.isNaN(runAt.getTime())) return false;
+    return runAt <= now && (!task.lastRunAt || new Date(task.lastRunAt) < runAt);
+  }
+  if (schedule.kind === 'cron') {
+    try {
+      const interval = cron().CronExpressionParser.parse(schedule.expr, {
+        currentDate: now,
+        tz: schedule.tz || 'UTC',
+      });
+      const prev = interval.prev().toDate();
+      const createdAt = validDate(task.createdAt);
+      const lastRunAt = validDate(task.lastRunAt);
+
+      if (createdAt && prev <= createdAt) return false;
+      return !lastRunAt || lastRunAt < prev;
+    } catch {
+      return false;
+    }
+  }
+  if (schedule.kind === 'interval') {
+    if (!task.lastRunAt) return true;
+    return now - new Date(task.lastRunAt) >= schedule.ms;
+  }
+  return false;
+}
+
+function startScheduler() {
+  console.log(`[AmalgmMCP:Scheduler] Starting (interval: ${SCHEDULER_INTERVAL_MS}ms)`);
+  schedulerTimer = setInterval(() => {
+    try {
+      const data = loadTasks();
+      const now = new Date();
+      for (const task of data.tasks) {
+        if (!task.enabled) continue;
+        if (isRunning(task.id)) continue;
+        if (isTaskDue(task, now)) {
+          executeTask(task).catch((err) => {
+            console.error(`[AmalgmMCP:Scheduler] Task ${task.id} error:`, err.message);
+          });
+        }
+      }
+    } catch (err) {
+      console.error('[AmalgmMCP:Scheduler] Poll error:', err.message);
+    }
+  }, SCHEDULER_INTERVAL_MS);
+}
+
+function stopScheduler() {
+  if (schedulerTimer) {
+    clearInterval(schedulerTimer);
+    schedulerTimer = null;
+  }
+}
+
+module.exports = { validateCronExpr, isTaskDue, startScheduler, stopScheduler };

package/runtime/scripts/amalgm-mcp/tasks/store.js

@@ -0,0 +1,154 @@
+/**
+ * Tasks storage — ~/.amalgm/tasks.json + ~/.amalgm/task-runs/{id}.jsonl
+ *
+ * Single writer, atomic rename. No dual-write to /persist (local-first).
+ */
+
+const path = require('path');
+const { TASKS_FILE, TASK_RUNS_DIR, STORAGE_DIR } = require('../config');
+const {
+  ensureDir,
+  readJson,
+  writeJsonAtomic,
+  cleanupStaleTmp,
+  appendJsonl,
+  tailJsonl,
+} = require('../lib/storage');
+const {
+  chatInputToLegacyFields,
+  getChatInputText,
+  normalizeChatInput,
+} = require('../../../lib/chatInput');
+const { normalizeTaskSchedule } = require('./schedule-normalization');
+const { DEFAULT_SELECTED_MODELS, getSelectedModel } = require('../lib/prefs');
+const credentialAdapter = require('../../credential-adapter');
+const { appendStateEvent } = require('../state/events');
+
+function normalizeStoredTask(task) {
+  const harness =
+    (task.chatInput && task.chatInput.agent && task.chatInput.agent.harness)
+    || task.harness
+    || 'claude_code';
+  const model =
+    (task.chatInput && task.chatInput.agent && task.chatInput.agent.model)
+    || task.model
+    || getSelectedModel(harness)
+    || DEFAULT_SELECTED_MODELS[harness]
+    || null;
+  const authMethod =
+    (task.chatInput && task.chatInput.agent && task.chatInput.agent.authMethod)
+    || task.authMethod
+    || (credentialAdapter.VALID_HARNESS_IDS.includes(harness)
+      ? credentialAdapter.getPersistedAuthMode(harness)
+      : 'amalgm');
+  const chatInput = normalizeChatInput(task.chatInput, {
+    prompt: task.prompt,
+    harness,
+    modelId: model,
+    authMethod,
+    cwd: task.projectPath,
+    projectPath: task.projectPath,
+  });
+  const legacy = chatInputToLegacyFields(chatInput, {
+    prompt: task.prompt,
+    harness,
+    modelId: model,
+    authMethod,
+    cwd: task.projectPath,
+    projectPath: task.projectPath,
+  });
+  const normalizedScheduleResult = normalizeTaskSchedule(task.schedule);
+  const schedule = normalizedScheduleResult.error ? task.schedule : normalizedScheduleResult.schedule;
+
+  return {
+    ...task,
+    schedule,
+    chatInput,
+    prompt: getChatInputText(chatInput, task.prompt) || legacy.prompt,
+    harness: legacy.harness || harness,
+    model: legacy.modelId || model,
+    authMethod: legacy.authMethod || authMethod,
+    projectPath: legacy.cwd || task.projectPath || null,
+  };
+}
+
+function migrateTasksData(data) {
+  let changed = false;
+  const tasks = Array.isArray(data.tasks)
+    ? data.tasks.map((task) => {
+        const normalizedTask = normalizeStoredTask(task);
+        if (JSON.stringify(normalizedTask) !== JSON.stringify(task)) {
+          changed = true;
+        }
+        return normalizedTask;
+      })
+    : [];
+
+  return {
+    changed,
+    data: {
+      version: typeof data.version === 'number' ? data.version : 1,
+      tasks,
+    },
+  };
+}
+
+function ensureTasksDirs() {
+  ensureDir(STORAGE_DIR);
+  ensureDir(TASK_RUNS_DIR);
+  cleanupStaleTmp(STORAGE_DIR, '.tasks.json');
+  if (!readJson(TASKS_FILE, null)) writeJsonAtomic(TASKS_FILE, { version: 1, tasks: [] });
+}
+
+function loadTasks() {
+  const raw = readJson(TASKS_FILE, { version: 1, tasks: [] });
+  const migrated = migrateTasksData(raw);
+  if (migrated.changed) {
+    writeJsonAtomic(TASKS_FILE, migrated.data);
+  }
+  return migrated.data;
+}
+
+function publishTasksChange(data, source = 'tasks') {
+  try {
+    appendStateEvent({
+      resource: 'tasks',
+      op: 'replace',
+      value: Array.isArray(data?.tasks) ? data.tasks : [],
+      source,
+    });
+  } catch (error) {
+    console.warn('[Tasks] Local Live Store publish failed:', error.message);
+  }
+}
+
+function saveTasks(data, options = {}) {
+  writeJsonAtomic(TASKS_FILE, data);
+  publishTasksChange(data, options.source || 'tasks:save');
+}
+
+function updateTaskMeta(taskId, updates) {
+  const data = loadTasks();
+  const task = data.tasks.find((t) => t.id === taskId);
+  if (task) {
+    Object.assign(task, updates);
+    saveTasks(data);
+  }
+}
+
+function appendRunLog(taskId, entry) {
+  appendJsonl(path.join(TASK_RUNS_DIR, `${taskId}.jsonl`), entry);
+}
+
+function readRunLog(taskId, limit = 20) {
+  return tailJsonl(path.join(TASK_RUNS_DIR, `${taskId}.jsonl`), limit);
+}
+
+module.exports = {
+  ensureTasksDirs,
+  loadTasks,
+  saveTasks,
+  updateTaskMeta,
+  appendRunLog,
+  readRunLog,
+};