amalgm 0.1.51 → 0.1.53

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

@@ -1,416 +0,0 @@
-/**
- * Scheduled-tasks MCP tools.
- *
- * 8 tools: create, list, get, update, delete, run_now, cancel, history.
- * Each entry is self-contained: name, description, inputSchema, handler.
- * Storage lives in ./store.js, execution in ./executor.js.
- */
-
-const crypto = require('crypto');
-const { textResult, errorResult } = require('../lib/tool-result');
-const { claimTaskRun, loadTasks, saveTasks, readRunLog } = require('./store');
-const { validateCronExpr } = require('./scheduler');
-const { normalizeTaskSchedule } = require('./schedule-normalization');
-const { executeTask, isRunning, getRunning, abortRunning } = require('./executor');
-const {
-  chatInputToLegacyFields,
-  getChatInputText,
-  normalizeChatInput,
-} = require('../../../lib/chatInput');
-const {
-  DEFAULT_SELECTED_MODELS,
-  getSelectedModel,
-  hydrateModelPreferences,
-} = require('../lib/prefs');
-const credentialAdapter = require('../../credential-adapter');
-const activeMemory = require('../../chat-core/tooling/active-memory');
-
-function resolveTaskHarness(harness, chatInput) {
-  const candidate =
-    (chatInput && chatInput.agent && typeof chatInput.agent.harness === 'string' && chatInput.agent.harness)
-    || (typeof harness === 'string' && harness)
-    || 'claude_code';
-  return candidate;
-}
-
-function resolveTaskModel(harness, model) {
-  if (typeof model === 'string' && model) return model;
-  return getSelectedModel(harness) || DEFAULT_SELECTED_MODELS[harness] || null;
-}
-
-function resolveTaskAuthMethod(harness, authMethod) {
-  if (typeof authMethod === 'string' && authMethod) return authMethod;
-  if (credentialAdapter.VALID_HARNESS_IDS.includes(harness)) {
-    return credentialAdapter.getPersistedAuthMode(harness);
-  }
-  return 'amalgm';
-}
-
-function normalizeTaskRecord(taskLike) {
-  const harness = resolveTaskHarness(taskLike.harness, taskLike.chatInput);
-  const model = resolveTaskModel(harness, taskLike.model);
-  const authMethod = resolveTaskAuthMethod(harness, taskLike.authMethod);
-  const chatInput = normalizeChatInput(taskLike.chatInput, {
-    prompt: taskLike.prompt,
-    harness,
-    modelId: model,
-    authMethod,
-    projectPath: taskLike.projectPath,
-    cwd: taskLike.projectPath,
-  });
-  const legacy = chatInputToLegacyFields(chatInput, {
-    prompt: taskLike.prompt,
-    harness,
-    modelId: model,
-    authMethod,
-    projectPath: taskLike.projectPath,
-    cwd: taskLike.projectPath,
-  });
-
-  return {
-    ...taskLike,
-    chatInput,
-    prompt: getChatInputText(chatInput, taskLike.prompt) || legacy.prompt,
-    harness: legacy.harness || harness,
-    model: legacy.modelId || model,
-    authMethod: legacy.authMethod || authMethod,
-    projectPath: legacy.cwd || taskLike.projectPath || null,
-  };
-}
-
-module.exports = [
-  {
-    name: 'scheduled_tasks_create',
-    description:
-      'Create a new scheduled task that runs a prompt on a schedule. Supports cron (recurring), once (one-shot), and interval (fixed ms) schedules.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string', description: 'Human-readable task name' },
-        schedule: {
-          type: 'object',
-          description: 'Schedule configuration',
-          properties: {
-            kind: {
-              type: 'string',
-              enum: ['cron', 'once', 'interval'],
-              description: 'cron=recurring, once=one-shot, interval=fixed ms',
-            },
-            expr: { type: 'string', description: 'Cron expression (for kind=cron), e.g. "0 9 * * *"' },
-            tz: { type: 'string', description: 'IANA timezone (defaults to the local user timezone)' },
-            at: { type: 'string', description: 'ISO datetime (for kind=once)' },
-            ms: { type: 'number', description: 'Interval in ms (for kind=interval, min 60000)' },
-          },
-          required: ['kind'],
-        },
-        description: { type: 'string', description: 'Optional markdown description shown in the UI' },
-        prompt: { type: 'string', description: 'The prompt to execute when the task runs' },
-        enabled: { type: 'boolean', description: 'Whether the task is active (default: true)' },
-        endsAt: { type: 'string', description: 'ISO datetime when the task auto-disables (null = never)' },
-        maxConcurrentRuns: { type: 'number', description: 'Max parallel executions (default: 1)' },
-        harness: { type: 'string', description: 'Agent harness (claude_code, codex, opencode)' },
-        model: { type: 'string', description: 'Model ID to use for execution' },
-        modelSettings: { type: 'object', description: 'Advanced model settings such as effort and fastMode' },
-        authMethod: { type: 'string', description: 'Auth method for this task run' },
-        projectPath: { type: 'string', description: 'Working directory path' },
-        chatInput: { type: 'object', description: 'Shared chat input shape for the task run' },
-      },
-      required: ['name', 'schedule'],
-    },
-    async handler({ name, description, schedule, prompt, enabled, endsAt, maxConcurrentRuns, harness, model, modelSettings, authMethod, projectPath, chatInput }) {
-      const normalizedScheduleResult = normalizeTaskSchedule(schedule);
-      if (normalizedScheduleResult.error) {
-        return errorResult(normalizedScheduleResult.error);
-      }
-      const normalizedSchedule = normalizedScheduleResult.schedule;
-
-      if (normalizedSchedule.kind === 'cron') {
-        const err = validateCronExpr(normalizedSchedule.expr, normalizedSchedule.tz);
-        if (err) return errorResult(`Invalid cron expression: ${err}`);
-      }
-      if (!prompt && !chatInput) {
-        return errorResult('prompt or chatInput is required');
-      }
-
-      await hydrateModelPreferences();
-
-      const task = normalizeTaskRecord({
-        id: crypto.randomUUID(),
-        name,
-        description: description || '',
-        enabled: enabled !== false,
-        schedule: normalizedSchedule,
-        prompt: prompt || null,
-        endsAt: endsAt || null,
-        maxConcurrentRuns: maxConcurrentRuns || 1,
-        harness: harness || null,
-        model: model || null,
-        modelSettings: modelSettings || null,
-        authMethod: authMethod || null,
-        projectPath: projectPath || null,
-        chatInput: chatInput || null,
-        createdAt: new Date().toISOString(),
-        lastRunAt: null,
-        lastStatus: null,
-      });
-      const data = loadTasks();
-      data.tasks.push(task);
-      saveTasks(data);
-      activeMemory.ensureConstructMemory({
-        type: 'task',
-        id: task.id,
-        name: task.name,
-        projectPath: task.projectPath,
-      }, { source: 'task:create' });
-      console.log(`[AmalgmMCP] Created task: ${task.id} (${task.name})`);
-      return textResult(`Task created successfully.\n\n${JSON.stringify(task, null, 2)}`);
-    },
-  },
-  {
-    name: 'scheduled_tasks_list',
-    description: 'List all scheduled tasks with their current status',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        enabled_only: { type: 'boolean', description: 'If true, only return enabled tasks' },
-      },
-    },
-    async handler({ enabled_only }) {
-      const data = loadTasks();
-      let tasks = data.tasks.map(normalizeTaskRecord);
-      if (enabled_only) tasks = tasks.filter((t) => t.enabled);
-      if (tasks.length === 0) return textResult('No scheduled tasks found.');
-      const summary = tasks
-        .map((t) => {
-          const running = isRunning(t.id) ? ' [RUNNING]' : '';
-          const sched =
-            t.schedule.kind === 'cron'
-              ? `cron: ${t.schedule.expr} (${t.schedule.tz || 'UTC'})`
-              : t.schedule.kind === 'once'
-                ? `once: ${t.schedule.at}`
-                : `every ${t.schedule.ms}ms`;
-          return `- ${t.name} (${t.id})\n  ${t.enabled ? 'enabled' : 'disabled'} | ${sched} | last: ${t.lastStatus || 'never'}${running}`;
-        })
-        .join('\n\n');
-      return textResult(summary);
-    },
-  },
-  {
-    name: 'scheduled_tasks_get',
-    description: 'Get detailed information about a specific task including recent run history',
-    inputSchema: {
-      type: 'object',
-      properties: { task_id: { type: 'string', description: 'The task ID' } },
-      required: ['task_id'],
-    },
-    async handler({ task_id }) {
-      const data = loadTasks();
-      const task = data.tasks.find((t) => t.id === task_id);
-      if (!task) return errorResult(`Task not found: ${task_id}`);
-      const normalizedTask = normalizeTaskRecord(task);
-      return textResult(
-        JSON.stringify(
-          { ...normalizedTask, isRunning: isRunning(task_id), recentRuns: readRunLog(task_id, 10) },
-          null,
-          2,
-        ),
-      );
-    },
-  },
-  {
-    name: 'scheduled_tasks_update',
-    description: 'Update properties of an existing scheduled task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        task_id: { type: 'string' },
-        name: { type: 'string' },
-        schedule: {
-          type: 'object',
-          properties: {
-            kind: { type: 'string', enum: ['cron', 'once', 'interval'] },
-            expr: { type: 'string' },
-            tz: { type: 'string' },
-            at: { type: 'string' },
-            ms: { type: 'number' },
-          },
-        },
-        description: { type: 'string' },
-        prompt: { type: 'string' },
-        enabled: { type: 'boolean' },
-        endsAt: { type: 'string' },
-        nextRunAt: { type: 'string' },
-        maxConcurrentRuns: { type: 'number' },
-        harness: { type: 'string' },
-        model: { type: 'string' },
-        modelSettings: { type: 'object' },
-        authMethod: { type: 'string' },
-        projectPath: { type: 'string' },
-        chatInput: { type: 'object' },
-      },
-      required: ['task_id'],
-    },
-    async handler({ task_id, name, description, schedule, prompt, enabled, endsAt, nextRunAt, maxConcurrentRuns, harness, model, modelSettings, authMethod, projectPath, chatInput }) {
-      const data = loadTasks();
-      const task = data.tasks.find((t) => t.id === task_id);
-      if (!task) return errorResult(`Task not found: ${task_id}`);
-
-      await hydrateModelPreferences();
-
-      if (schedule) {
-        const normalizedScheduleResult = normalizeTaskSchedule(schedule);
-        if (normalizedScheduleResult.error) {
-          return errorResult(normalizedScheduleResult.error);
-        }
-
-        const normalizedSchedule = normalizedScheduleResult.schedule;
-        if (normalizedSchedule.kind === 'cron') {
-          const err = validateCronExpr(normalizedSchedule.expr, normalizedSchedule.tz);
-          if (err) return errorResult(`Invalid cron expression: ${err}`);
-        }
-        task.schedule = normalizedSchedule;
-      }
-      if (name !== undefined) task.name = name;
-      if (description !== undefined) task.description = description || '';
-      if (prompt !== undefined) task.prompt = prompt;
-      if (enabled !== undefined) task.enabled = enabled;
-      if (endsAt !== undefined) task.endsAt = endsAt || null;
-      if (nextRunAt !== undefined) task.nextRunAt = nextRunAt || null;
-      if (maxConcurrentRuns !== undefined) task.maxConcurrentRuns = maxConcurrentRuns;
-      if (harness !== undefined) task.harness = harness || null;
-      if (model !== undefined) task.model = model || null;
-      if (modelSettings !== undefined) task.modelSettings = modelSettings || null;
-      if (authMethod !== undefined) task.authMethod = authMethod || null;
-      if (projectPath !== undefined) task.projectPath = projectPath || null;
-      if (chatInput !== undefined) task.chatInput = chatInput || null;
-      if (
-        chatInput === undefined
-        && (
-          prompt !== undefined
-          || harness !== undefined
-          || model !== undefined
-          || authMethod !== undefined
-          || projectPath !== undefined
-        )
-      ) {
-        const existingNonTextParts = Array.isArray(task.chatInput?.parts)
-          ? task.chatInput.parts.filter((part) => part.type !== 'text')
-          : [];
-        task.chatInput = {
-          ...(task.chatInput || {}),
-          parts: [
-            ...existingNonTextParts,
-            ...((typeof task.prompt === 'string' && task.prompt)
-              ? [{ type: 'text', text: task.prompt }]
-              : []),
-          ],
-          agent: {
-            ...(task.chatInput?.agent || {}),
-            ...(task.harness ? { harness: task.harness } : {}),
-            ...(task.model ? { model: task.model } : {}),
-            ...(task.authMethod ? { authMethod: task.authMethod } : {}),
-          },
-          tools: task.chatInput?.tools || { mcpAppIds: [] },
-          execution: {
-            ...(task.chatInput?.execution || {}),
-            ...(projectPath !== undefined ? { cwd: task.projectPath || null } : {}),
-          },
-        };
-      }
-
-      const normalizedTask = normalizeTaskRecord(task);
-      Object.assign(task, normalizedTask);
-
-      saveTasks(data, { preserveNextRunAt: nextRunAt !== undefined });
-      activeMemory.ensureConstructMemory({
-        type: 'task',
-        id: task.id,
-        name: task.name,
-        projectPath: task.projectPath,
-      }, { source: 'task:update' });
-      console.log(`[AmalgmMCP] Updated task: ${task.id} (${task.name})`);
-      return textResult(`Task updated.\n\n${JSON.stringify(task, null, 2)}`);
-    },
-  },
-  {
-    name: 'scheduled_tasks_delete',
-    description: 'Delete a scheduled task permanently',
-    inputSchema: {
-      type: 'object',
-      properties: { task_id: { type: 'string' } },
-      required: ['task_id'],
-    },
-    async handler({ task_id }) {
-      const data = loadTasks();
-      const idx = data.tasks.findIndex((t) => t.id === task_id);
-      if (idx === -1) return errorResult(`Task not found: ${task_id}`);
-      abortRunning(task_id);
-      const deleted = data.tasks.splice(idx, 1)[0];
-      saveTasks(data);
-      console.log(`[AmalgmMCP] Deleted task: ${task_id} (${deleted.name})`);
-      return textResult(`Task "${deleted.name}" deleted.`);
-    },
-  },
-  {
-    name: 'scheduled_tasks_run_now',
-    description: 'Trigger immediate execution of a scheduled task, bypassing its schedule',
-    inputSchema: {
-      type: 'object',
-      properties: { task_id: { type: 'string' } },
-      required: ['task_id'],
-    },
-    async handler({ task_id }) {
-      const data = loadTasks();
-      const task = data.tasks.find((t) => t.id === task_id);
-      if (!task) return errorResult(`Task not found: ${task_id}`);
-      if (isRunning(task_id)) return textResult(`Task "${task.name}" is already running.`);
-      const claimed = claimTaskRun(task, {
-        now: new Date(),
-        scheduledFor: new Date().toISOString(),
-        source: 'tasks:run-now',
-      });
-      if (!claimed) return textResult(`Task "${task.name}" is already running.`);
-      executeTask(claimed.task, claimed.run).catch((err) =>
-        console.error(`[AmalgmMCP:RunNow] ${task_id} failed:`, err.message),
-      );
-      return textResult(`Task "${task.name}" triggered. Running in background.`);
-    },
-  },
-  {
-    name: 'scheduled_tasks_cancel',
-    description: 'Cancel a currently running task execution',
-    inputSchema: {
-      type: 'object',
-      properties: { task_id: { type: 'string' } },
-      required: ['task_id'],
-    },
-    async handler({ task_id }) {
-      const running = getRunning(task_id);
-      if (!running) return textResult(`No running execution for task: ${task_id}`);
-      abortRunning(task_id);
-      return textResult(`Cancelled execution of task ${task_id} (run: ${running.runId}).`);
-    },
-  },
-  {
-    name: 'scheduled_tasks_history',
-    description: 'Get execution history for a scheduled task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        task_id: { type: 'string' },
-        limit: { type: 'number', description: 'Max runs to return (default: 20)' },
-      },
-      required: ['task_id'],
-    },
-    async handler({ task_id, limit }) {
-      const data = loadTasks();
-      const task = data.tasks.find((t) => t.id === task_id);
-      if (!task) return errorResult(`Task not found: ${task_id}`);
-      const runs = readRunLog(task_id, limit || 20);
-      if (runs.length === 0) return textResult(`No execution history for "${task.name}".`);
-      return textResult(
-        `Execution history for "${task.name}":\n\n${JSON.stringify(runs, null, 2)}`,
-      );
-    },
-  },
-];