@vellumai/assistant 0.3.22 → 0.3.24

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

@@ -1,164 +0,0 @@
-import * as net from 'node:net';
-
-import {
-  clearPIN,
-  getParentalControlSettings,
-  hasPIN,
-  setPIN,
-  updateParentalControlSettings,
-  verifyPIN,
-} from '../../security/parental-control-store.js';
-import { getLogger } from '../../util/logger.js';
-import type {
-  ParentalControlGetRequest,
-  ParentalControlSetPinRequest,
-  ParentalControlUpdateRequest,
-  ParentalControlVerifyPinRequest,
-} from '../ipc-protocol.js';
-import { defineHandlers, type HandlerContext } from './shared.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/ipc-contract/parental-control.ts

@@ -1,109 +0,0 @@
-// Parental control IPC types.
-//
-// The parental control system lets a parent or guardian lock the assistant
-// behind a 6-digit PIN and configure per-topic content restrictions and
-// per-category tool blocks. All mutating operations require the PIN when
-// one has been set.
-
-// === Shared data types ===
-
-/**
- * Topics that can be individually blocked.
- * All unlisted topics are allowed.
- */
-export type ParentalContentTopic =
-  | 'violence'
-  | 'adult_content'
-  | 'political'
-  | 'gambling'
-  | 'drugs';
-
-/**
- * Broad tool categories that can be disabled for age-appropriate use.
- * When a category is blocked, individual tool invocations within that
- * category are rejected before the permission pipeline runs.
- */
-export type ParentalToolCategory =
-  | 'computer_use'
-  | 'network'
-  | 'shell'
-  | 'file_write';
-
-// === Client → Server ===
-
-/** Retrieve the current parental control settings and PIN status. */
-export interface ParentalControlGetRequest {
-  type: 'parental_control_get';
-}
-
-/** Verify a PIN attempt without changing any state. Useful to gate an unlock-settings flow before showing the full panel. */
-export interface ParentalControlVerifyPinRequest {
-  type: 'parental_control_verify_pin';
-  pin: string;
-}
-
-/** Set, change, or clear the parental control PIN. To set for the first time provide only new_pin. To change provide current_pin and new_pin. To clear provide current_pin and set clear:true. */
-export interface ParentalControlSetPinRequest {
-  type: 'parental_control_set_pin';
-  current_pin?: string;
-  new_pin?: string;
-  clear?: boolean;
-}
-
-/** Update parental control settings. Requires the PIN when parental mode is already enabled. */
-export interface ParentalControlUpdateRequest {
-  type: 'parental_control_update';
-  /** Current PIN — required when parental mode is already enabled. */
-  pin?: string;
-  /** Enable or disable parental control mode. */
-  enabled?: boolean;
-  /** Full replacement list of blocked content topics. */
-  content_restrictions?: ParentalContentTopic[];
-  /** Full replacement list of blocked tool categories. */
-  blocked_tool_categories?: ParentalToolCategory[];
-}
-
-// === Server → Client ===
-
-export interface ParentalControlGetResponse {
-  type: 'parental_control_get_response';
-  enabled: boolean;
-  has_pin: boolean;
-  content_restrictions: ParentalContentTopic[];
-  blocked_tool_categories: ParentalToolCategory[];
-}
-
-export interface ParentalControlVerifyPinResponse {
-  type: 'parental_control_verify_pin_response';
-  verified: boolean;
-}
-
-export interface ParentalControlSetPinResponse {
-  type: 'parental_control_set_pin_response';
-  success: boolean;
-  error?: string;
-}
-
-export interface ParentalControlUpdateResponse {
-  type: 'parental_control_update_response';
-  success: boolean;
-  error?: string;
-  enabled: boolean;
-  has_pin: boolean;
-  content_restrictions: ParentalContentTopic[];
-  blocked_tool_categories: ParentalToolCategory[];
-}
-
-// --- Domain-level union aliases (consumed by the barrel file) ---
-
-export type _ParentalControlClientMessages =
-  | ParentalControlGetRequest
-  | ParentalControlVerifyPinRequest
-  | ParentalControlSetPinRequest
-  | ParentalControlUpdateRequest;
-
-export type _ParentalControlServerMessages =
-  | ParentalControlGetResponse
-  | ParentalControlVerifyPinResponse
-  | ParentalControlSetPinResponse
-  | ParentalControlUpdateResponse;

package/src/security/parental-control-store.ts

@@ -1,184 +0,0 @@
-/**
- * Parental control settings and PIN management.
- *
- * Non-secret settings (enabled state, content restrictions, blocked tool
- * categories) are persisted to `~/.vellum/parental-control.json`.
- *
- * The PIN hash and salt are stored in the encrypted key store under the
- * account `parental:pin` as the hex string `"<salt>:<hash>"`.
- *
- * PIN hashing uses SHA-256 with a random 16-byte salt to prevent offline
- * dictionary attacks. Comparison uses timingSafeEqual to avoid timing leaks.
- */
-
-import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
-import { readFileSync, writeFileSync } from 'node:fs';
-import { dirname,join } from 'node:path';
-
-import type { ParentalContentTopic, ParentalToolCategory } from '../daemon/ipc-contract/parental-control.js';
-import { ensureDir,pathExists } from '../util/fs.js';
-import { getLogger } from '../util/logger.js';
-import { getRootDir } from '../util/platform.js';
-import { deleteKey,getKey, setKey } from './encrypted-store.js';
-
-const log = getLogger('parental-control');
-
-const PIN_ACCOUNT = 'parental:pin';
-
-export type { ParentalContentTopic, ParentalToolCategory };
-
-export interface ParentalControlSettings {
-  enabled: boolean;
-  contentRestrictions: ParentalContentTopic[];
-  blockedToolCategories: ParentalToolCategory[];
-}
-
-const DEFAULT_SETTINGS: ParentalControlSettings = {
-  enabled: false,
-  contentRestrictions: [],
-  blockedToolCategories: [],
-};
-
-function getSettingsPath(): string {
-  return join(getRootDir(), 'parental-control.json');
-}
-
-// ---------------------------------------------------------------------------
-// Settings I/O
-// ---------------------------------------------------------------------------
-
-export function getParentalControlSettings(): ParentalControlSettings {
-  try {
-    const file = getSettingsPath();
-    if (!pathExists(file)) return { ...DEFAULT_SETTINGS };
-    const raw = readFileSync(file, 'utf-8');
-    const parsed = JSON.parse(raw) as Partial<ParentalControlSettings>;
-    return {
-      enabled: typeof parsed.enabled === 'boolean' ? parsed.enabled : false,
-      contentRestrictions: Array.isArray(parsed.contentRestrictions) ? parsed.contentRestrictions : [],
-      blockedToolCategories: Array.isArray(parsed.blockedToolCategories) ? parsed.blockedToolCategories : [],
-    };
-  } catch {
-    return { ...DEFAULT_SETTINGS };
-  }
-}
-
-function saveSettings(settings: ParentalControlSettings): void {
-  const file = getSettingsPath();
-  ensureDir(dirname(file));
-  writeFileSync(file, JSON.stringify(settings, null, 2), { encoding: 'utf-8' });
-}
-
-export function updateParentalControlSettings(
-  patch: Partial<ParentalControlSettings>,
-): ParentalControlSettings {
-  const current = getParentalControlSettings();
-  const next: ParentalControlSettings = {
-    enabled: patch.enabled !== undefined ? patch.enabled : current.enabled,
-    contentRestrictions: patch.contentRestrictions !== undefined
-      ? patch.contentRestrictions
-      : current.contentRestrictions,
-    blockedToolCategories: patch.blockedToolCategories !== undefined
-      ? patch.blockedToolCategories
-      : current.blockedToolCategories,
-  };
-  saveSettings(next);
-  return next;
-}
-
-// ---------------------------------------------------------------------------
-// PIN management
-// ---------------------------------------------------------------------------
-
-/** Returns true if a parental control PIN has been configured. */
-export function hasPIN(): boolean {
-  return getKey(PIN_ACCOUNT) !== undefined;
-}
-
-function hashPIN(pin: string, salt: Buffer): Buffer {
-  return createHash('sha256').update(salt).update(pin).digest();
-}
-
-/**
- * Set a new PIN. Rejects if `pin` is not exactly 6 ASCII digits.
- * Throws if the store write fails.
- */
-export function setPIN(pin: string): void {
-  if (!/^\d{6}$/.test(pin)) {
-    throw new Error('PIN must be exactly 6 digits');
-  }
-  const salt = randomBytes(16);
-  const hash = hashPIN(pin, salt);
-  const stored = `${salt.toString('hex')}:${hash.toString('hex')}`;
-  if (!setKey(PIN_ACCOUNT, stored)) {
-    throw new Error('Failed to persist PIN — encrypted store write error');
-  }
-  log.info('Parental control PIN set');
-}
-
-/**
- * Verify a PIN attempt. Returns true on match, false on mismatch or if no
- * PIN has been configured. Uses constant-time comparison to prevent timing
- * attacks.
- */
-export function verifyPIN(pin: string): boolean {
-  if (!/^\d{6}$/.test(pin)) return false;
-  const stored = getKey(PIN_ACCOUNT);
-  if (!stored) return false;
-
-  const colonIdx = stored.indexOf(':');
-  if (colonIdx === -1) return false;
-
-  try {
-    const salt = Buffer.from(stored.slice(0, colonIdx), 'hex');
-    const expectedHash = Buffer.from(stored.slice(colonIdx + 1), 'hex');
-    const actualHash = hashPIN(pin, salt);
-    if (actualHash.length !== expectedHash.length) return false;
-    return timingSafeEqual(actualHash, expectedHash);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Remove the PIN. The caller is responsible for requiring PIN verification
- * before calling this.
- */
-export function clearPIN(): void {
-  deleteKey(PIN_ACCOUNT);
-  log.info('Parental control PIN cleared');
-}
-
-// ---------------------------------------------------------------------------
-// Tool category → tool name mapping
-// ---------------------------------------------------------------------------
-
-/**
- * Tool name prefixes that belong to each blocked category.
- * A tool is considered blocked if its name starts with any of the listed
- * prefixes (case-sensitive).
- */
-export const TOOL_CATEGORY_PREFIXES: Record<ParentalToolCategory, string[]> = {
-  computer_use: ['cu_', 'computer_use', 'screenshot', 'accessibility_'],
-  network: ['web_fetch', 'web_search', 'browser_'],
-  shell: ['bash', 'terminal', 'host_shell'],
-  file_write: ['file_write', 'file_edit', 'multi_edit', 'file_delete', 'git'],
-};
-
-/**
- * Returns true if the given tool name falls within any of the currently
- * blocked tool categories.
- */
-export function isToolBlocked(toolName: string): boolean {
-  const { enabled, blockedToolCategories } = getParentalControlSettings();
-  if (!enabled || blockedToolCategories.length === 0) return false;
-
-  for (const category of blockedToolCategories) {
-    const prefixes = TOOL_CATEGORY_PREFIXES[category];
-    // Guard against unknown categories that may appear after deserialization of
-    // settings written by a newer client version — skip rather than throw.
-    if (!prefixes) continue;
-    if (prefixes.some((p) => toolName.startsWith(p))) return true;
-  }
-  return false;
-}