@vellumai/assistant 0.3.4 → 0.3.6

package/src/daemon/handlers/config-parental.ts

@@ -0,0 +1,163 @@
+import * as net from 'node:net';
+import type {
+  ParentalControlGetRequest,
+  ParentalControlVerifyPinRequest,
+  ParentalControlSetPinRequest,
+  ParentalControlUpdateRequest,
+} from '../ipc-protocol.js';
+import { defineHandlers, type HandlerContext } from './shared.js';
+import {
+  getParentalControlSettings,
+  updateParentalControlSettings,
+  hasPIN,
+  setPIN,
+  verifyPIN,
+  clearPIN,
+} from '../../security/parental-control-store.js';
+import { getLogger } from '../../util/logger.js';
+
+const log = getLogger('parental-control');
+
+function sendGetResponse(socket: net.Socket, ctx: HandlerContext): void {
+  const settings = getParentalControlSettings();
+  ctx.send(socket, {
+    type: 'parental_control_get_response',
+    enabled: settings.enabled,
+    has_pin: hasPIN(),
+    content_restrictions: settings.contentRestrictions,
+    blocked_tool_categories: settings.blockedToolCategories,
+  });
+}
+
+export function handleParentalControlGet(
+  _msg: ParentalControlGetRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  sendGetResponse(socket, ctx);
+}
+
+export function handleParentalControlVerifyPin(
+  msg: ParentalControlVerifyPinRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  const verified = verifyPIN(msg.pin);
+  ctx.send(socket, {
+    type: 'parental_control_verify_pin_response',
+    verified,
+  });
+}
+
+export function handleParentalControlSetPin(
+  msg: ParentalControlSetPinRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    const pinExists = hasPIN();
+
+    if (msg.clear) {
+      // Clearing the PIN — must verify current PIN first
+      if (pinExists) {
+        if (!msg.current_pin || !verifyPIN(msg.current_pin)) {
+          ctx.send(socket, {
+            type: 'parental_control_set_pin_response',
+            success: false,
+            error: 'Current PIN is incorrect',
+          });
+          return;
+        }
+      }
+      clearPIN();
+      ctx.send(socket, {
+        type: 'parental_control_set_pin_response',
+        success: true,
+      });
+      return;
+    }
+
+    if (!msg.new_pin) {
+      ctx.send(socket, {
+        type: 'parental_control_set_pin_response',
+        success: false,
+        error: 'new_pin is required',
+      });
+      return;
+    }
+
+    if (pinExists) {
+      // Changing existing PIN — must verify current PIN first
+      if (!msg.current_pin || !verifyPIN(msg.current_pin)) {
+        ctx.send(socket, {
+          type: 'parental_control_set_pin_response',
+          success: false,
+          error: 'Current PIN is incorrect',
+        });
+        return;
+      }
+    }
+
+    setPIN(msg.new_pin);
+    ctx.send(socket, {
+      type: 'parental_control_set_pin_response',
+      success: true,
+    });
+  } catch (err) {
+    log.error({ err }, 'Failed to set parental control PIN');
+    ctx.send(socket, {
+      type: 'parental_control_set_pin_response',
+      success: false,
+      error: err instanceof Error ? err.message : 'Internal error',
+    });
+  }
+}
+
+export function handleParentalControlUpdate(
+  msg: ParentalControlUpdateRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  const settings = getParentalControlSettings();
+  const pinExists = hasPIN();
+
+  // Require PIN verification when parental mode is already enabled
+  if (settings.enabled && pinExists) {
+    if (!msg.pin || !verifyPIN(msg.pin)) {
+      ctx.send(socket, {
+        type: 'parental_control_update_response',
+        success: false,
+        error: 'PIN required to change parental control settings',
+        enabled: settings.enabled,
+        has_pin: pinExists,
+        content_restrictions: settings.contentRestrictions,
+        blocked_tool_categories: settings.blockedToolCategories,
+      });
+      return;
+    }
+  }
+
+  const updated = updateParentalControlSettings({
+    enabled: msg.enabled,
+    contentRestrictions: msg.content_restrictions,
+    blockedToolCategories: msg.blocked_tool_categories,
+  });
+
+  log.info({ enabled: updated.enabled }, 'Parental control settings updated');
+
+  ctx.send(socket, {
+    type: 'parental_control_update_response',
+    success: true,
+    enabled: updated.enabled,
+    has_pin: hasPIN(),
+    content_restrictions: updated.contentRestrictions,
+    blocked_tool_categories: updated.blockedToolCategories,
+  });
+}
+
+export const parentalControlHandlers = defineHandlers({
+  parental_control_get: handleParentalControlGet,
+  parental_control_verify_pin: handleParentalControlVerifyPin,
+  parental_control_set_pin: handleParentalControlSetPin,
+  parental_control_update: handleParentalControlUpdate,
+});

package/src/daemon/handlers/config-scheduling.ts

@@ -0,0 +1,172 @@
+import * as net from 'node:net';
+import { listSchedules, updateSchedule, deleteSchedule, describeCronExpression, getSchedule, createScheduleRun, completeScheduleRun } from '../../schedule/schedule-store.js';
+import { createConversation } from '../../memory/conversation-store.js';
+import { listReminders, cancelReminder } from '../../tools/reminder/reminder-store.js';
+import type {
+  ScheduleToggle,
+  ScheduleRemove,
+  ScheduleRunNow,
+  ReminderCancel,
+} from '../ipc-protocol.js';
+import { log, defineHandlers, type HandlerContext } from './shared.js';
+
+export function handleSchedulesList(socket: net.Socket, ctx: HandlerContext): void {
+  const jobs = listSchedules();
+  ctx.send(socket, {
+    type: 'schedules_list_response',
+    schedules: jobs.map((j) => ({
+      id: j.id,
+      name: j.name,
+      enabled: j.enabled,
+      syntax: j.syntax,
+      expression: j.expression,
+      cronExpression: j.cronExpression,
+      timezone: j.timezone,
+      message: j.message,
+      nextRunAt: j.nextRunAt,
+      lastRunAt: j.lastRunAt,
+      lastStatus: j.lastStatus,
+      description: j.syntax === 'cron' ? describeCronExpression(j.cronExpression) : j.expression,
+    })),
+  });
+}
+
+export function handleScheduleToggle(
+  msg: ScheduleToggle,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    updateSchedule(msg.id, { enabled: msg.enabled });
+    log.info({ id: msg.id, enabled: msg.enabled }, 'Schedule toggled via client');
+  } catch (err) {
+    log.error({ err }, 'Failed to toggle schedule');
+  }
+  handleSchedulesList(socket, ctx);
+}
+
+export function handleScheduleRemove(
+  msg: ScheduleRemove,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    const removed = deleteSchedule(msg.id);
+    if (!removed) {
+      log.warn({ id: msg.id }, 'Schedule not found for removal');
+    } else {
+      log.info({ id: msg.id }, 'Schedule removed via client');
+    }
+  } catch (err) {
+    log.error({ err }, 'Failed to remove schedule');
+  }
+  handleSchedulesList(socket, ctx);
+}
+
+export async function handleScheduleRunNow(
+  msg: ScheduleRunNow,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  const schedule = getSchedule(msg.id);
+  if (!schedule) {
+    log.warn({ id: msg.id }, 'Schedule not found for run-now');
+    return;
+  }
+
+  // Check if message is a task invocation (run_task:<task_id>)
+  const taskMatch = schedule.message.match(/^run_task:(\S+)$/);
+  if (taskMatch) {
+    const taskId = taskMatch[1];
+    try {
+      log.info({ jobId: schedule.id, name: schedule.name, taskId }, 'Executing scheduled task manually (run now)');
+      const { runTask } = await import('../../tasks/task-runner.js');
+      const result = await runTask(
+        { taskId, workingDir: process.cwd() },
+        async (conversationId, message, taskRunId) => {
+          const session = await ctx.getOrCreateSession(conversationId, socket, true);
+          (session as unknown as { taskRunId?: string }).taskRunId = taskRunId;
+          await session.processMessage(message, [], (event) => {
+            ctx.send(socket, event);
+          });
+        },
+      );
+
+      const runId = createScheduleRun(schedule.id, result.conversationId);
+      if (result.status === 'failed') {
+        completeScheduleRun(runId, { status: 'error', error: result.error ?? 'Task run failed' });
+      } else {
+        completeScheduleRun(runId, { status: 'ok' });
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log.warn({ err, jobId: schedule.id, name: schedule.name, taskId }, 'Manual scheduled task execution failed');
+      const fallbackConversation = createConversation({ title: `Schedule (manual): ${schedule.name}`, source: 'schedule' });
+      const runId = createScheduleRun(schedule.id, fallbackConversation.id);
+      completeScheduleRun(runId, { status: 'error', error: message });
+    }
+    handleSchedulesList(socket, ctx);
+    return;
+  }
+
+  const conversation = createConversation({ title: `Schedule (manual): ${schedule.name}`, source: 'schedule' });
+  const runId = createScheduleRun(schedule.id, conversation.id);
+
+  try {
+    log.info({ jobId: schedule.id, name: schedule.name, conversationId: conversation.id }, 'Executing schedule manually (run now)');
+    const session = await ctx.getOrCreateSession(conversation.id, socket, true);
+    await session.processMessage(schedule.message, [], (event) => {
+      ctx.send(socket, event);
+    });
+    completeScheduleRun(runId, { status: 'ok' });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.warn({ err, jobId: schedule.id, name: schedule.name }, 'Manual schedule execution failed');
+    completeScheduleRun(runId, { status: 'error', error: message });
+  }
+  handleSchedulesList(socket, ctx);
+}
+
+export function handleRemindersList(socket: net.Socket, ctx: HandlerContext): void {
+  const items = listReminders();
+  ctx.send(socket, {
+    type: 'reminders_list_response',
+    reminders: items.map((r) => ({
+      id: r.id,
+      label: r.label,
+      message: r.message,
+      fireAt: r.fireAt,
+      mode: r.mode,
+      status: r.status,
+      firedAt: r.firedAt,
+      createdAt: r.createdAt,
+    })),
+  });
+}
+
+export function handleReminderCancel(
+  msg: ReminderCancel,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    const cancelled = cancelReminder(msg.id);
+    if (!cancelled) {
+      log.warn({ id: msg.id }, 'Reminder not found or already fired/cancelled');
+    } else {
+      log.info({ id: msg.id }, 'Reminder cancelled via client');
+    }
+  } catch (err) {
+    log.error({ err }, 'Failed to cancel reminder');
+  }
+  handleRemindersList(socket, ctx);
+}
+
+export const schedulingHandlers = defineHandlers({
+  schedules_list: (_msg, socket, ctx) => handleSchedulesList(socket, ctx),
+  schedule_toggle: handleScheduleToggle,
+  schedule_remove: handleScheduleRemove,
+  schedule_run_now: handleScheduleRunNow,
+  reminders_list: (_msg, socket, ctx) => handleRemindersList(socket, ctx),
+  reminder_cancel: handleReminderCancel,
+});

package/src/daemon/handlers/config-slack.ts

@@ -0,0 +1,92 @@
+import * as net from 'node:net';
+import { loadRawConfig, saveRawConfig } from '../../config/loader.js';
+import { postToSlackWebhook } from '../../slack/slack-webhook.js';
+import { getApp } from '../../memory/app-store.js';
+import type {
+  ShareToSlackRequest,
+  SlackWebhookConfigRequest,
+} from '../ipc-protocol.js';
+import { log, defineHandlers, type HandlerContext } from './shared.js';
+
+export async function handleShareToSlack(
+  msg: ShareToSlackRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  try {
+    const config = loadRawConfig();
+    const webhookUrl = config.slackWebhookUrl as string | undefined;
+    if (!webhookUrl) {
+      ctx.send(socket, {
+        type: 'share_to_slack_response',
+        success: false,
+        error: 'No Slack webhook URL configured. Provide one here in the chat, or set it from the Settings page.',
+      });
+      return;
+    }
+
+    const app = getApp(msg.appId);
+    if (!app) {
+      ctx.send(socket, {
+        type: 'share_to_slack_response',
+        success: false,
+        error: `App not found: ${msg.appId}`,
+      });
+      return;
+    }
+
+    await postToSlackWebhook(
+      webhookUrl,
+      app.name,
+      app.description ?? '',
+      '\u{1F4F1}',
+    );
+
+    ctx.send(socket, { type: 'share_to_slack_response', success: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err, appId: msg.appId }, 'Failed to share app to Slack');
+    ctx.send(socket, {
+      type: 'share_to_slack_response',
+      success: false,
+      error: message,
+    });
+  }
+}
+
+export function handleSlackWebhookConfig(
+  msg: SlackWebhookConfigRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    const config = loadRawConfig();
+    if (msg.action === 'get') {
+      ctx.send(socket, {
+        type: 'slack_webhook_config_response',
+        webhookUrl: (config.slackWebhookUrl as string) ?? undefined,
+        success: true,
+      });
+    } else {
+      config.slackWebhookUrl = msg.webhookUrl ?? '';
+      saveRawConfig(config);
+      ctx.send(socket, {
+        type: 'slack_webhook_config_response',
+        success: true,
+      });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err }, 'Failed to handle Slack webhook config');
+    ctx.send(socket, {
+      type: 'slack_webhook_config_response',
+      success: false,
+      error: message,
+    });
+  }
+}
+
+export const slackHandlers = defineHandlers({
+  share_to_slack: handleShareToSlack,
+  slack_webhook_config: handleSlackWebhookConfig,
+});