work-ally 0.2.0-alpha.1

package/bridge/src/runtime-user-input.ts

@@ -0,0 +1,403 @@
+import type { McpToolApprovalRule } from './config.ts';
+import type { UserInputQuestion, UserInputRequest } from './types.ts';
+
+export interface RuntimeUserInputAutoResolution {
+  kind: 'mcp_tool_call_approval';
+  serverName: string;
+  toolName: string;
+  matchedRule: string;
+  answerLabel: string;
+  answers?: Record<string, { answers: string[] }>;
+  elicitationResponse?: { action: 'accept'; content: unknown | null };
+}
+
+interface SchemaChoice {
+  label: string;
+  value: unknown;
+  description: string;
+}
+
+const MCP_TOOL_APPROVAL_RE = /^The\s+([^\s]+)\s+MCP server wants to run the tool\s+"([^"]+)".*Allow this action\?$/i;
+const PREFERRED_APPROVAL_LABELS = ['Approve this Session', 'Approve Once'];
+const ACCEPT_WORDS = new Set([
+  'accept',
+  'approve',
+  'approved',
+  'approve once',
+  'approve this session',
+  'yes',
+  'y',
+  'ok',
+  'okay',
+  'continue',
+  'done',
+  'open',
+  '同意',
+]);
+const DECLINE_WORDS = new Set(['deny', 'decline', 'declined', 'reject', 'rejected', 'no', 'n', '拒绝']);
+const CANCEL_WORDS = new Set(['cancel', 'cancelled', 'canceled', 'stop', '取消']);
+
+function normalizeRulePart(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+function normalizeSchemaObject(input: unknown): Record<string, unknown> | null {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    return null;
+  }
+  return input as Record<string, unknown>;
+}
+
+function choiceFromVariant(input: unknown): SchemaChoice | null {
+  const variant = normalizeSchemaObject(input);
+  if (!variant) {
+    return null;
+  }
+  const description = typeof variant.description === 'string' ? variant.description : '';
+
+  if (Object.prototype.hasOwnProperty.call(variant, 'const')) {
+    const value = variant.const;
+    return {
+      label: typeof variant.title === 'string' ? variant.title : String(value),
+      value,
+      description,
+    };
+  }
+
+  if (Array.isArray(variant.enum) && variant.enum.length === 1) {
+    const value = variant.enum[0];
+    return {
+      label: typeof variant.title === 'string' ? variant.title : String(value),
+      value,
+      description,
+    };
+  }
+
+  return null;
+}
+
+function extractSchemaChoices(schema: Record<string, unknown> | null): SchemaChoice[] {
+  if (!schema) {
+    return [];
+  }
+
+  const choices: SchemaChoice[] = [];
+  const seen = new Set<string>();
+  const push = (choice: SchemaChoice | null) => {
+    if (!choice) {
+      return;
+    }
+    const key = `${choice.label}::${JSON.stringify(choice.value)}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    choices.push(choice);
+  };
+
+  if (Array.isArray(schema.enum)) {
+    for (const value of schema.enum) {
+      push({
+        label: String(value),
+        value,
+        description: typeof schema.description === 'string' ? schema.description : '',
+      });
+    }
+  }
+
+  for (const key of ['oneOf', 'anyOf']) {
+    const variants = schema[key];
+    if (!Array.isArray(variants)) {
+      continue;
+    }
+    for (const variant of variants) {
+      push(choiceFromVariant(variant));
+    }
+  }
+
+  return choices;
+}
+
+function matchesRule(rule: McpToolApprovalRule, serverName: string, toolName: string): boolean {
+  const normalizedServer = normalizeRulePart(serverName);
+  const normalizedTool = normalizeRulePart(toolName);
+  const serverMatches = rule.serverName === '*' || rule.serverName === normalizedServer;
+  const toolMatches = rule.toolName === '*' || rule.toolName === normalizedTool;
+  return serverMatches && toolMatches;
+}
+
+function parseMcpToolApproval(text: string | null | undefined): { serverName: string; toolName: string } | null {
+  const match = text?.trim().match(MCP_TOOL_APPROVAL_RE);
+  if (!match) {
+    return null;
+  }
+  return {
+    serverName: match[1],
+    toolName: match[2],
+  };
+}
+
+function detectMcpToolApprovalTarget(request: UserInputRequest): { serverName: string; toolName: string } | null {
+  if (request.kind === 'mcp_elicitation' && request.elicitation?.message) {
+    return parseMcpToolApproval(request.elicitation.message);
+  }
+  if (!request.questions?.length) {
+    return null;
+  }
+  return parseMcpToolApproval(request.questions[0]?.question);
+}
+
+function pickApprovalLabel(questions: UserInputQuestion[]): string | null {
+  const labels = questions
+    .flatMap((question) => (question.options || []).map((option) => option.label))
+    .filter(Boolean);
+  return PREFERRED_APPROVAL_LABELS.find((label) => labels.includes(label)) || null;
+}
+
+function formSchemaRoot(request: UserInputRequest): Record<string, unknown> | null {
+  if (request.kind !== 'mcp_elicitation') {
+    return null;
+  }
+  return normalizeSchemaObject(request.elicitation?.requestedSchema);
+}
+
+function schemaProperties(request: UserInputRequest): Record<string, unknown> {
+  const root = formSchemaRoot(request);
+  return normalizeSchemaObject(root?.properties) || {};
+}
+
+function propertySchema(request: UserInputRequest, questionId: string): Record<string, unknown> | null {
+  const value = schemaProperties(request)[questionId];
+  return normalizeSchemaObject(value);
+}
+
+function normalizeBoolean(raw: string): boolean | null {
+  const normalized = normalizeRulePart(raw);
+  if (ACCEPT_WORDS.has(normalized) || ['true', '1'].includes(normalized)) {
+    return true;
+  }
+  if (DECLINE_WORDS.has(normalized) || ['false', '0'].includes(normalized)) {
+    return false;
+  }
+  return null;
+}
+
+function isNegativeLabel(value: string): boolean {
+  const normalized = normalizeRulePart(value);
+  return DECLINE_WORDS.has(normalized) || CANCEL_WORDS.has(normalized);
+}
+
+function preferredAffirmativeValue(schema: Record<string, unknown> | null, question: UserInputQuestion): unknown {
+  const choices = extractSchemaChoices(schema);
+  if (choices.length) {
+    return choices.find((choice) => !isNegativeLabel(choice.label) && !isNegativeLabel(String(choice.value)))?.value ?? choices[0].value;
+  }
+  if (schema?.type === 'boolean') {
+    return true;
+  }
+  const optionLabel = (question.options || []).map((option) => option.label).find((label) => !isNegativeLabel(label));
+  if (optionLabel) {
+    return optionLabel;
+  }
+  return null;
+}
+
+function coerceScalarValue(raw: string, schema: Record<string, unknown> | null, question: UserInputQuestion): unknown {
+  const trimmed = raw.trim();
+  const choices = extractSchemaChoices(schema);
+  if (choices.length) {
+    const normalized = normalizeRulePart(trimmed);
+    for (const choice of choices) {
+      if (normalizeRulePart(choice.label) === normalized || normalizeRulePart(String(choice.value)) === normalized) {
+        return choice.value;
+      }
+    }
+  }
+
+  switch (schema?.type) {
+    case 'boolean': {
+      const value = normalizeBoolean(trimmed);
+      return value === null ? trimmed : value;
+    }
+    case 'integer': {
+      const value = Number(trimmed);
+      return Number.isInteger(value) ? value : trimmed;
+    }
+    case 'number': {
+      const value = Number(trimmed);
+      return Number.isFinite(value) ? value : trimmed;
+    }
+    case 'array': {
+      const itemSchema = normalizeSchemaObject(schema.items);
+      const parts = trimmed
+        .split(trimmed.includes('\n') ? /\r?\n/ : /\s*,\s*/)
+        .map((part) => part.trim())
+        .filter(Boolean);
+      const source = parts.length ? parts : [trimmed];
+      return source.map((part) => coerceScalarValue(part, itemSchema, question));
+    }
+    default:
+      break;
+  }
+
+  if (question.options?.length) {
+    const optionMatch = question.options.find((option) => normalizeRulePart(option.label) === normalizeRulePart(trimmed));
+    if (optionMatch) {
+      return optionMatch.label;
+    }
+  }
+
+  return trimmed;
+}
+
+function coerceAnswerWithAcceptFallback(raw: string, schema: Record<string, unknown> | null, question: UserInputQuestion): unknown {
+  const trimmed = raw.trim();
+  const value = coerceScalarValue(trimmed, schema, question);
+  if (typeof value === 'string' && value === trimmed && actionFromText(trimmed) === 'accept') {
+    const preferred = preferredAffirmativeValue(schema, question);
+    if (preferred !== null) {
+      return preferred;
+    }
+  }
+  return value;
+}
+
+function buildFormElicitationContent(request: UserInputRequest, text: string): unknown {
+  const trimmed = text.trim();
+  const root = formSchemaRoot(request);
+  const questions = request.questions || [];
+  const rootIsObject = Boolean(root && (root.type === 'object' || Object.keys(schemaProperties(request)).length > 0));
+
+  if (!questions.length) {
+    return rootIsObject ? { response: trimmed } : trimmed;
+  }
+
+  if (questions.length === 1) {
+    const question = questions[0];
+    const schema = propertySchema(request, question.id) || root;
+    const value = coerceAnswerWithAcceptFallback(trimmed, schema, question);
+    if (!rootIsObject) {
+      return value;
+    }
+    return { [question.id]: value };
+  }
+
+  const answers: Record<string, unknown> = {};
+  const byQuestion = new Map(questions.map((question) => [question.id, question]));
+  const lines = trimmed.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  let matchedAny = false;
+
+  for (const line of lines) {
+    const match = line.match(/^([A-Za-z0-9_.-]+)\s*[:：]\s*(.+)$/);
+    if (!match) {
+      continue;
+    }
+    const [, questionId, answer] = match;
+    const question = byQuestion.get(questionId);
+    if (!question) {
+      continue;
+    }
+    answers[questionId] = coerceAnswerWithAcceptFallback(answer, propertySchema(request, questionId), question);
+    matchedAny = true;
+  }
+
+  if (!matchedAny) {
+    for (const question of questions) {
+      answers[question.id] = coerceAnswerWithAcceptFallback(trimmed, propertySchema(request, question.id), question);
+    }
+  }
+
+  return answers;
+}
+
+function actionFromText(text: string): 'accept' | 'decline' | 'cancel' | null {
+  const normalized = normalizeRulePart(text);
+  if (CANCEL_WORDS.has(normalized)) {
+    return 'cancel';
+  }
+  if (DECLINE_WORDS.has(normalized)) {
+    return 'decline';
+  }
+  if (ACCEPT_WORDS.has(normalized)) {
+    return 'accept';
+  }
+  return null;
+}
+
+export function buildElicitationResponseFromReply(
+  request: UserInputRequest,
+  text: string,
+): { action: 'accept' | 'decline' | 'cancel'; content: unknown | null } | null {
+  if (request.kind !== 'mcp_elicitation' || !request.elicitation) {
+    return null;
+  }
+
+  const explicitAction = actionFromText(text);
+  if (request.elicitation.mode === 'url') {
+    return {
+      action: explicitAction || 'accept',
+      content: null,
+    };
+  }
+
+  if (explicitAction === 'decline' || explicitAction === 'cancel') {
+    return {
+      action: explicitAction,
+      content: null,
+    };
+  }
+
+  return {
+    action: 'accept',
+    content: buildFormElicitationContent(request, text),
+  };
+}
+
+export function maybeAutoResolveRuntimeUserInput(
+  request: UserInputRequest,
+  rules: McpToolApprovalRule[],
+): RuntimeUserInputAutoResolution | null {
+  const target = detectMcpToolApprovalTarget(request);
+  if (!target) {
+    return null;
+  }
+
+  const matchedRule = rules.find((rule) => matchesRule(rule, target.serverName, target.toolName));
+  if (!matchedRule) {
+    return null;
+  }
+
+  const answerLabel = pickApprovalLabel(request.questions) || 'Approve this Session';
+
+  if (request.kind === 'mcp_elicitation') {
+    const elicitationResponse = buildElicitationResponseFromReply(request, answerLabel);
+    if (!elicitationResponse || elicitationResponse.action !== 'accept') {
+      return null;
+    }
+    return {
+      kind: 'mcp_tool_call_approval',
+      serverName: target.serverName,
+      toolName: target.toolName,
+      matchedRule: `${matchedRule.serverName}:${matchedRule.toolName}`,
+      answerLabel,
+      elicitationResponse,
+    };
+  }
+
+  if (!request.questions?.length) {
+    return null;
+  }
+
+  return {
+    kind: 'mcp_tool_call_approval',
+    serverName: target.serverName,
+    toolName: target.toolName,
+    matchedRule: `${matchedRule.serverName}:${matchedRule.toolName}`,
+    answerLabel,
+    answers: {
+      [request.questions[0].id]: {
+        answers: [answerLabel],
+      },
+    },
+  };
+}

package/bridge/src/scheduler.ts

@@ -0,0 +1,239 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import cronParser from 'cron-parser';
+import YAML from 'yaml';
+import { nowIso, readJsonFile, writeJsonFile } from './utils.ts';
+
+export interface RoutineDefinition {
+  id: string;
+  description?: string;
+  schedule?: string;
+  enabled?: boolean;
+  type?: 'prompt' | 'memory_digest';
+  prompt?: string;
+  thread_mode?: 'reuse' | 'new';
+  push?: { kind: 'none' | 'default_im' };
+  writeback?: { kind: 'none' | 'append_markdown'; path?: string };
+}
+
+export interface DueRoutine {
+  routine: RoutineDefinition;
+  slot: string;
+}
+
+export interface RunningStateEntry {
+  startedAt: string;
+  pid: number | null;
+}
+
+export interface SchedulerState {
+  disabled: string[];
+  lastRuns: Record<string, string>;
+  running: Record<string, RunningStateEntry>;
+  routineThreads: Record<string, string>;
+}
+
+function normalizeRunningEntry(value: unknown): RunningStateEntry | null {
+  if (typeof value === 'string') {
+    return { startedAt: value, pid: null };
+  }
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+  const parsed = value as Partial<RunningStateEntry>;
+  if (typeof parsed.startedAt !== 'string') {
+    return null;
+  }
+  return {
+    startedAt: parsed.startedAt,
+    pid: typeof parsed.pid === 'number' ? parsed.pid : null,
+  };
+}
+
+function isPidAlive(pid: number | null): boolean {
+  if (!pid || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeState(value: unknown): SchedulerState {
+  const parsed = (value && typeof value === 'object') ? value as Partial<SchedulerState> : {};
+  const running = parsed.running && typeof parsed.running === 'object'
+    ? Object.fromEntries(
+      Object.entries(parsed.running).flatMap(([id, entry]) => {
+        const normalized = normalizeRunningEntry(entry);
+        return normalized ? [[id, normalized]] : [];
+      }),
+    )
+    : {};
+  return {
+    disabled: Array.isArray(parsed.disabled) ? parsed.disabled.filter((item): item is string => typeof item === 'string') : [],
+    lastRuns: parsed.lastRuns && typeof parsed.lastRuns === 'object' ? parsed.lastRuns as Record<string, string> : {},
+    running,
+    routineThreads: parsed.routineThreads && typeof parsed.routineThreads === 'object' ? parsed.routineThreads as Record<string, string> : {},
+  };
+}
+
+export class Scheduler {
+  private readonly routinesDir: string;
+  private readonly stateFile: string;
+  private readonly timeZone: string;
+  private readonly fallbackRoutinesDir: string | null;
+
+  constructor(routinesDir: string, stateFile: string, timeZone = 'UTC', fallbackRoutinesDir: string | null = null) {
+    this.routinesDir = routinesDir;
+    this.stateFile = stateFile;
+    this.timeZone = timeZone;
+    this.fallbackRoutinesDir = fallbackRoutinesDir;
+  }
+
+  private pruneStaleRunning(state: SchedulerState): SchedulerState {
+    let changed = false;
+    for (const [id, entry] of Object.entries(state.running)) {
+      if (isPidAlive(entry.pid)) {
+        continue;
+      }
+      delete state.running[id];
+      changed = true;
+    }
+    if (changed) {
+      this.saveState(state);
+    }
+    return state;
+  }
+
+  loadState(): SchedulerState {
+    return this.pruneStaleRunning(normalizeState(readJsonFile(this.stateFile, { disabled: [], lastRuns: {}, running: {}, routineThreads: {} })));
+  }
+
+  saveState(state: SchedulerState): void {
+    writeJsonFile(this.stateFile, state);
+  }
+
+  listRoutines(): RoutineDefinition[] {
+    const roots = [this.routinesDir, this.fallbackRoutinesDir].filter((value, index, list): value is string => Boolean(value) && list.indexOf(value as string) === index);
+    const files = roots.flatMap((root) => {
+      if (!fs.existsSync(root)) {
+        return [];
+      }
+      return fs.readdirSync(root)
+        .filter((name) => name.endsWith('.yaml') || name.endsWith('.yml'))
+        .map((name) => path.join(root, name));
+    });
+
+    if (files.length === 0) {
+      return [];
+    }
+
+    const seen = new Set<string>();
+    return files
+      .map((fullPath) => {
+        const parsed = YAML.parse(fs.readFileSync(fullPath, 'utf8')) || {};
+        const fileName = path.basename(fullPath);
+        const routine: RoutineDefinition = {
+          id: parsed.id || path.basename(fileName, path.extname(fileName)),
+          description: parsed.description,
+          schedule: parsed.schedule,
+          enabled: parsed.enabled !== false,
+          type: parsed.type || 'prompt',
+          prompt: parsed.prompt,
+          thread_mode: parsed.thread_mode || 'reuse',
+          push: parsed.push || { kind: 'none' },
+          writeback: parsed.writeback || { kind: 'none' },
+        };
+        return routine;
+      })
+      .filter((routine) => {
+        if (seen.has(routine.id)) {
+          return false;
+        }
+        seen.add(routine.id);
+        return true;
+      })
+      .sort((a, b) => a.id.localeCompare(b.id));
+  }
+
+  enableRoutine(id: string): void {
+    const state = this.loadState();
+    state.disabled = state.disabled.filter((item) => item !== id);
+    this.saveState(state);
+  }
+
+  disableRoutine(id: string): void {
+    const state = this.loadState();
+    if (!state.disabled.includes(id)) {
+      state.disabled.push(id);
+    }
+    this.saveState(state);
+  }
+
+  previousSlotForRoutine(routine: RoutineDefinition, now = new Date()): string | null {
+    if (!routine.schedule) {
+      return null;
+    }
+    const interval = cronParser.CronExpressionParser.parse(routine.schedule, { currentDate: now, tz: this.timeZone });
+    return interval.prev().toDate().toISOString();
+  }
+
+  computeDue(now = new Date()): DueRoutine[] {
+    const state = this.loadState();
+    return this.listRoutines().flatMap((routine) => {
+      if (routine.enabled === false) return [];
+      if (state.disabled.includes(routine.id)) return [];
+      if (state.running[routine.id]) return [];
+      const slot = this.previousSlotForRoutine(routine, now);
+      if (!slot) return [];
+      if (state.lastRuns[routine.id] === slot) {
+        return [];
+      }
+
+      return [{ routine, slot }];
+    });
+  }
+
+  claimRun(id: string, startedAt = nowIso()): boolean {
+    const state = this.loadState();
+    if (state.running[id]) {
+      return false;
+    }
+    state.running[id] = { startedAt, pid: process.pid };
+    this.saveState(state);
+    return true;
+  }
+
+  releaseRun(id: string): void {
+    const state = this.loadState();
+    delete state.running[id];
+    this.saveState(state);
+  }
+
+  markRun(id: string, slot = nowIso()): void {
+    const state = this.loadState();
+    state.lastRuns[id] = slot;
+    delete state.running[id];
+    this.saveState(state);
+  }
+
+  getRoutineThread(id: string): string | null {
+    const state = this.loadState();
+    return state.routineThreads[id] || null;
+  }
+
+  bindRoutineThread(id: string, threadId: string): void {
+    const state = this.loadState();
+    state.routineThreads[id] = threadId;
+    this.saveState(state);
+  }
+
+  clearRoutineThread(id: string): void {
+    const state = this.loadState();
+    delete state.routineThreads[id];
+    this.saveState(state);
+  }
+}