amalgm 0.0.0 → 0.0.1

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

@@ -0,0 +1,391 @@
+/**
+ * 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 { 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');
+
+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' },
+        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, 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,
+        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);
+      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' },
+        maxConcurrentRuns: { type: 'number' },
+        harness: { type: 'string' },
+        model: { type: 'string' },
+        authMethod: { type: 'string' },
+        projectPath: { type: 'string' },
+        chatInput: { type: 'object' },
+      },
+      required: ['task_id'],
+    },
+    async handler({ task_id, name, description, schedule, prompt, enabled, endsAt, maxConcurrentRuns, harness, model, 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 (maxConcurrentRuns !== undefined) task.maxConcurrentRuns = maxConcurrentRuns;
+      if (harness !== undefined) task.harness = harness || null;
+      if (model !== undefined) task.model = model || 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);
+      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.`);
+      executeTask(task).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)}`,
+      );
+    },
+  },
+];

package/runtime/scripts/amalgm-mcp/user-api-keys/rest.js

@@ -0,0 +1,105 @@
+/**
+ * /user-api-keys REST routes for the Next.js API to call.
+ * Not part of the MCP tool surface — used by the internal UI.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { AMALGM_DIR } = require('../config');
+const { getEnvKeyNameForHarness } = require('../../../lib/harnesses.js');
+const { deleteCredential, listCredentials, upsertCredential } = require('../../chat-core/credentials/store');
+
+const CREDENTIALS_PATH = path.join(AMALGM_DIR, '.amalgm-credentials');
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function decodeShellValue(rawValue) {
+  const value = String(rawValue ?? '').trim();
+  if (value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1).replace(/'\\''/g, "'");
+  }
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value
+      .slice(1, -1)
+      .replace(/\\"/g, '"')
+      .replace(/\\\$/g, '$')
+      .replace(/\\\\/g, '\\');
+  }
+  return value;
+}
+
+function readCredentialExports() {
+  const values = {};
+  try {
+    const raw = fs.readFileSync(CREDENTIALS_PATH, 'utf-8');
+    for (const line of raw.split(/\r?\n/)) {
+      const match = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)\s*$/);
+      if (!match) continue;
+      values[match[1]] = decodeShellValue(match[2]);
+    }
+  } catch {
+    // No existing credential file.
+  }
+  return values;
+}
+
+function writeCredentialExports(values) {
+  const keys = Object.keys(values).sort();
+  const content = keys
+    .map((key) => `export ${key}=${shellQuote(values[key])}`)
+    .join('\n') + '\n';
+  fs.mkdirSync(path.dirname(CREDENTIALS_PATH), { recursive: true });
+  fs.writeFileSync(CREDENTIALS_PATH, content, { mode: 0o600 });
+}
+
+async function handleSave(body, sendJson) {
+  try {
+    const { harnessId, apiKey } = body || {};
+
+    if (!harnessId || !apiKey) {
+      return sendJson(400, { error: 'harnessId and apiKey are required' });
+    }
+
+    const envKeyName = getEnvKeyNameForHarness(harnessId);
+    const values = readCredentialExports();
+    values[envKeyName] = apiKey;
+    writeCredentialExports(values);
+    const baseUrl = harnessId === 'claude_code'
+      ? 'https://api.anthropic.com'
+      : harnessId === 'opencode'
+        ? 'https://ai-gateway.vercel.sh/v1'
+        : 'https://api.openai.com/v1';
+    upsertCredential(AMALGM_DIR, {
+      name: harnessId === 'claude_code' ? 'Anthropic' : harnessId === 'opencode' ? 'Vercel AI Gateway' : 'OpenAI',
+      baseUrl,
+      key: apiKey,
+    });
+
+    sendJson(200, { keyHint: `...${String(apiKey).slice(-4)}` });
+  } catch (error) {
+    sendJson(500, {
+      error: error instanceof Error ? error.message : 'Failed to save API key',
+    });
+  }
+}
+
+async function handleDelete(sendJson) {
+  try {
+    fs.rmSync(CREDENTIALS_PATH, { force: true });
+    for (const credential of listCredentials(AMALGM_DIR)) {
+      deleteCredential(AMALGM_DIR, credential.id);
+    }
+    sendJson(200, { ok: true });
+  } catch (error) {
+    sendJson(500, {
+      error: error instanceof Error ? error.message : 'Failed to remove API key',
+    });
+  }
+}
+
+module.exports = {
+  handleDelete,
+  handleSave,
+};