claude-code-workflow 6.1.3 → 6.2.1

package/src/core/session-scanner.ts

@@ -0,0 +1,283 @@
+import { glob } from 'glob';
+import { readFile, readdir, stat, access } from 'fs/promises';
+import { constants } from 'fs';
+import { join, basename } from 'path';
+import type { SessionMetadata, SessionType } from '../types/session.js';
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+interface SessionData extends SessionMetadata {
+  path: string;
+  isActive: boolean;
+  archived_at?: string | null;
+  workflow_type?: string | null;
+}
+
+interface ScanSessionsResult {
+  active: SessionData[];
+  archived: SessionData[];
+  hasReviewData: boolean;
+}
+
+/**
+ * Scan .workflow directory for active and archived sessions
+ * @param workflowDir - Path to .workflow directory
+ * @returns Active and archived sessions
+ */
+export async function scanSessions(workflowDir: string): Promise<ScanSessionsResult> {
+  const result: ScanSessionsResult = {
+    active: [],
+    archived: [],
+    hasReviewData: false
+  };
+
+  if (!await fileExists(workflowDir)) {
+    return result;
+  }
+
+    // Scan active sessions
+  const activeDir = join(workflowDir, 'active');
+  if (await fileExists(activeDir)) {
+    const activeSessions = await findWfsSessions(activeDir);
+    const activeSessionDataPromises = activeSessions.map(async (sessionName) => {
+      const sessionPath = join(activeDir, sessionName);
+      const sessionData = await readSessionData(sessionPath);
+      if (sessionData) {
+        // Check for review data
+        if (await fileExists(join(sessionPath, '.review'))) {
+          result.hasReviewData = true;
+        }
+        return {
+          ...sessionData,
+          path: sessionPath,
+          isActive: true
+        };
+      }
+      return null;
+    });
+
+    const activeSessionData = (await Promise.all(activeSessionDataPromises)).filter((s): s is SessionData => s !== null);
+    result.active.push(...activeSessionData);
+  }
+
+    // Scan archived sessions
+  const archivesDir = join(workflowDir, 'archives');
+  if (await fileExists(archivesDir)) {
+    const archivedSessions = await findWfsSessions(archivesDir);
+    const archivedSessionDataPromises = archivedSessions.map(async (sessionName) => {
+      const sessionPath = join(archivesDir, sessionName);
+      const sessionData = await readSessionData(sessionPath);
+      if (sessionData) {
+        return {
+          ...sessionData,
+          path: sessionPath,
+          isActive: false
+        };
+      }
+      return null;
+    });
+
+    const archivedSessionData = (await Promise.all(archivedSessionDataPromises)).filter((s): s is SessionData => s !== null);
+    result.archived.push(...archivedSessionData);
+  }
+
+  // Sort by creation date (newest first)
+  result.active.sort((a, b) => new Date(b.created || 0).getTime() - new Date(a.created || 0).getTime());
+  result.archived.sort((a, b) => {
+    const aDate = a.archived_at || a.created || 0;
+    const bDate = b.archived_at || b.created || 0;
+    return new Date(bDate).getTime() - new Date(aDate).getTime();
+  });
+
+  return result;
+}
+
+/**
+ * Find WFS-* directories in a given path
+ * @param dir - Directory to search
+ * @returns Array of session directory names
+ */
+async function findWfsSessions(dir: string): Promise<string[]> {
+  try {
+    // Use glob for cross-platform pattern matching
+    const sessions = await glob('WFS-*/', {
+      cwd: dir,
+      absolute: false
+    });
+    // Remove trailing slashes from directory names
+    return sessions.map(s => s.replace(/\/$/, ''));
+  } catch {
+    // Fallback: manual directory listing
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      return entries
+        .filter(e => e.isDirectory() && e.name.startsWith('WFS-'))
+        .map(e => e.name);
+    } catch {
+      return [];
+    }
+  }
+}
+
+/**
+ * Parse timestamp from session name
+ * Supports formats: WFS-xxx-20251128172537 or WFS-xxx-20251120-170640
+ * @param sessionName - Session directory name
+ * @returns ISO date string or null
+ */
+function parseTimestampFromName(sessionName: string): string | null {
+  // Format: 14-digit timestamp (YYYYMMDDHHmmss)
+  const match14 = sessionName.match(/(\d{14})$/);
+  if (match14) {
+    const ts = match14[1];
+    return `${ts.slice(0,4)}-${ts.slice(4,6)}-${ts.slice(6,8)}T${ts.slice(8,10)}:${ts.slice(10,12)}:${ts.slice(12,14)}Z`;
+  }
+
+  // Format: 8-digit date + 6-digit time separated by hyphen (YYYYMMDD-HHmmss)
+  const match8_6 = sessionName.match(/(\d{8})-(\d{6})$/);
+  if (match8_6) {
+    const d = match8_6[1];
+    const t = match8_6[2];
+    return `${d.slice(0,4)}-${d.slice(4,6)}-${d.slice(6,8)}T${t.slice(0,2)}:${t.slice(2,4)}:${t.slice(4,6)}Z`;
+  }
+
+  return null;
+}
+
+/**
+ * Infer session type from session name pattern
+ * @param sessionName - Session directory name
+ * @returns Inferred type
+ */
+function inferTypeFromName(sessionName: string): SessionType {
+  const name = sessionName.toLowerCase();
+
+  if (name.includes('-review-') || name.includes('-code-review-')) {
+    return 'review';
+  }
+  if (name.includes('-test-')) {
+    return 'test';
+  }
+  if (name.includes('-docs-')) {
+    return 'docs';
+  }
+  if (name.includes('-tdd-')) {
+    return 'tdd';
+  }
+
+  return 'workflow';
+}
+
+/**
+ * Read session data from workflow-session.json or create minimal from directory
+ * @param sessionPath - Path to session directory
+ * @returns Session data object or null if invalid
+ */
+async function readSessionData(sessionPath: string): Promise<SessionData | null> {
+  const sessionFile = join(sessionPath, 'workflow-session.json');
+  const sessionName = basename(sessionPath);
+
+  if (await fileExists(sessionFile)) {
+    try {
+      const data = JSON.parse(await readFile(sessionFile, 'utf8')) as Record<string, unknown>;
+
+      // Multi-level type detection: JSON type > workflow_type > infer from name
+      let type = (data.type as SessionType) || (data.workflow_type as SessionType) || inferTypeFromName(sessionName);
+
+      // Normalize workflow_type values
+      if (type === 'test_session' as SessionType) type = 'test';
+      if (type === 'implementation' as SessionType) type = 'workflow';
+
+      return {
+        id: (data.session_id as string) || sessionName,
+        type,
+        status: (data.status as 'active' | 'paused' | 'completed' | 'archived') || 'active',
+        project: (data.project as string) || (data.description as string) || '',
+        description: (data.description as string) || (data.project as string) || '',
+        created: (data.created_at as string) || (data.initialized_at as string) || (data.timestamp as string) || '',
+        updated: (data.updated_at as string) || (data.created_at as string) || '',
+        path: sessionPath,
+        isActive: true,
+        archived_at: (data.archived_at as string) || null,
+        workflow_type: (data.workflow_type as string) || null  // Keep original for reference
+      };
+    } catch {
+      // Fall through to minimal session
+    }
+  }
+
+  // Fallback: create minimal session from directory info
+  // Try to extract timestamp from session name first
+  const timestampFromName = parseTimestampFromName(sessionName);
+  const inferredType = inferTypeFromName(sessionName);
+
+  try {
+    const stats = await stat(sessionPath);
+    const createdAt = timestampFromName || stats.birthtime.toISOString();
+    return {
+      id: sessionName,
+      type: inferredType,
+      status: 'active',
+      project: '',
+      description: '',
+      created: createdAt,
+      updated: createdAt,
+      path: sessionPath,
+      isActive: true,
+      archived_at: null,
+      workflow_type: null
+    };
+  } catch {
+    // Even if stat fails, return with name-extracted data
+    if (timestampFromName) {
+      return {
+        id: sessionName,
+        type: inferredType,
+        status: 'active',
+        project: '',
+        description: '',
+        created: timestampFromName,
+        updated: timestampFromName,
+        path: sessionPath,
+        isActive: true,
+        archived_at: null,
+        workflow_type: null
+      };
+    }
+    return null;
+  }
+}
+
+/**
+ * Check if session has review data
+ * @param sessionPath - Path to session directory
+ * @returns True if review data exists
+ */
+export async function hasReviewData(sessionPath: string): Promise<boolean> {
+  const reviewDir = join(sessionPath, '.review');
+  return await fileExists(reviewDir);
+}
+
+/**
+ * Get list of task files in session
+ * @param sessionPath - Path to session directory
+ * @returns Array of task file names
+ */
+export async function getTaskFiles(sessionPath: string): Promise<string[]> {
+  const taskDir = join(sessionPath, '.task');
+  if (!await fileExists(taskDir)) {
+    return [];
+  }
+
+  try {
+    return await glob('IMPL-*.json', { cwd: taskDir, absolute: false });
+  } catch {
+    return [];
+  }
+}

package/src/core/websocket.ts

@@ -0,0 +1,190 @@
+// @ts-nocheck
+import { createHash } from 'crypto';
+
+// WebSocket clients for real-time notifications
+export const wsClients = new Set();
+
+export function handleWebSocketUpgrade(req, socket, head) {
+  const key = req.headers['sec-websocket-key'];
+  const acceptKey = createHash('sha1')
+    .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+    .digest('base64');
+
+  const responseHeaders = [
+    'HTTP/1.1 101 Switching Protocols',
+    'Upgrade: websocket',
+    'Connection: Upgrade',
+    `Sec-WebSocket-Accept: ${acceptKey}`,
+    '',
+    ''
+  ].join('\r\n');
+
+  socket.write(responseHeaders);
+
+  // Add to clients set
+  wsClients.add(socket);
+  console.log(`[WS] Client connected (${wsClients.size} total)`);
+
+  // Handle incoming messages
+  socket.on('data', (buffer) => {
+    try {
+      const frame = parseWebSocketFrame(buffer);
+      if (!frame) return;
+
+      const { opcode, payload } = frame;
+
+      switch (opcode) {
+        case 0x1: // Text frame
+          if (payload) {
+            console.log('[WS] Received:', payload);
+          }
+          break;
+        case 0x8: // Close frame
+          socket.end();
+          break;
+        case 0x9: // Ping frame - respond with Pong
+          const pongFrame = Buffer.alloc(2);
+          pongFrame[0] = 0x8A; // Pong opcode with FIN bit
+          pongFrame[1] = 0x00; // No payload
+          socket.write(pongFrame);
+          break;
+        case 0xA: // Pong frame - ignore
+          break;
+        default:
+          // Ignore other frame types (binary, continuation)
+          break;
+      }
+    } catch (e) {
+      // Ignore parse errors
+    }
+  });
+
+  // Handle disconnect
+  socket.on('close', () => {
+    wsClients.delete(socket);
+    console.log(`[WS] Client disconnected (${wsClients.size} remaining)`);
+  });
+
+  socket.on('error', () => {
+    wsClients.delete(socket);
+  });
+}
+
+/**
+ * Parse WebSocket frame (simplified)
+ * Returns { opcode, payload } or null
+ */
+export function parseWebSocketFrame(buffer) {
+  if (buffer.length < 2) return null;
+
+  const firstByte = buffer[0];
+  const opcode = firstByte & 0x0f; // Extract opcode (bits 0-3)
+
+  // Opcode types:
+  // 0x0 = continuation, 0x1 = text, 0x2 = binary
+  // 0x8 = close, 0x9 = ping, 0xA = pong
+
+  const secondByte = buffer[1];
+  const isMasked = (secondByte & 0x80) !== 0;
+  let payloadLength = secondByte & 0x7f;
+
+  let offset = 2;
+  if (payloadLength === 126) {
+    payloadLength = buffer.readUInt16BE(2);
+    offset = 4;
+  } else if (payloadLength === 127) {
+    payloadLength = Number(buffer.readBigUInt64BE(2));
+    offset = 10;
+  }
+
+  let mask = null;
+  if (isMasked) {
+    mask = buffer.slice(offset, offset + 4);
+    offset += 4;
+  }
+
+  const payload = buffer.slice(offset, offset + payloadLength);
+
+  if (isMasked && mask) {
+    for (let i = 0; i < payload.length; i++) {
+      payload[i] ^= mask[i % 4];
+    }
+  }
+
+  return { opcode, payload: payload.toString('utf8') };
+}
+
+/**
+ * Create WebSocket frame
+ */
+export function createWebSocketFrame(data) {
+  const payload = Buffer.from(JSON.stringify(data), 'utf8');
+  const length = payload.length;
+
+  let frame;
+  if (length <= 125) {
+    frame = Buffer.alloc(2 + length);
+    frame[0] = 0x81; // Text frame, FIN
+    frame[1] = length;
+    payload.copy(frame, 2);
+  } else if (length <= 65535) {
+    frame = Buffer.alloc(4 + length);
+    frame[0] = 0x81;
+    frame[1] = 126;
+    frame.writeUInt16BE(length, 2);
+    payload.copy(frame, 4);
+  } else {
+    frame = Buffer.alloc(10 + length);
+    frame[0] = 0x81;
+    frame[1] = 127;
+    frame.writeBigUInt64BE(BigInt(length), 2);
+    payload.copy(frame, 10);
+  }
+
+  return frame;
+}
+
+/**
+ * Broadcast message to all connected WebSocket clients
+ */
+export function broadcastToClients(data) {
+  const frame = createWebSocketFrame(data);
+
+  for (const client of wsClients) {
+    try {
+      client.write(frame);
+    } catch (e) {
+      wsClients.delete(client);
+    }
+  }
+
+  console.log(`[WS] Broadcast to ${wsClients.size} clients:`, data.type);
+}
+
+/**
+ * Extract session ID from file path
+ */
+export function extractSessionIdFromPath(filePath) {
+  // Normalize path
+  const normalized = filePath.replace(/\\/g, '/');
+
+  // Look for session pattern: WFS-xxx, WRS-xxx, etc.
+  const sessionMatch = normalized.match(/\/(W[A-Z]S-[^/]+)\//);
+  if (sessionMatch) {
+    return sessionMatch[1];
+  }
+
+  // Look for .workflow/.sessions/xxx pattern
+  const sessionsMatch = normalized.match(/\.workflow\/\.sessions\/([^/]+)/);
+  if (sessionsMatch) {
+    return sessionsMatch[1];
+  }
+
+  // Look for lite-plan/lite-fix pattern
+  const liteMatch = normalized.match(/\.(lite-plan|lite-fix)\/([^/]+)/);
+  if (liteMatch) {
+    return liteMatch[2];
+  }
+
+  return null;
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+/**
+ * CCW - Claude Code Workflow CLI
+ * Main exports for programmatic usage
+ */
+
+export { run } from './cli.js';
+export { scanSessions } from './core/session-scanner.js';
+export { aggregateData } from './core/data-aggregator.js';
+export { generateDashboard } from './core/dashboard-generator.js';
+export { CacheManager, createDashboardCache } from './core/cache-manager.js';

package/src/mcp-server/index.ts

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+/**
+ * CCW MCP Server
+ * Exposes CCW tools through the Model Context Protocol
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { getAllToolSchemas, executeTool, executeToolWithProgress } from '../tools/index.js';
+import type { ToolSchema, ToolResult } from '../types/tool.js';
+import { getProjectRoot, getAllowedDirectories } from '../utils/path-validator.js';
+
+const SERVER_NAME = 'ccw-tools';
+const SERVER_VERSION = '6.2.0';
+
+// Environment variable names for documentation
+const ENV_PROJECT_ROOT = 'CCW_PROJECT_ROOT';
+const ENV_ALLOWED_DIRS = 'CCW_ALLOWED_DIRS';
+
+// Default enabled tools (core set)
+const DEFAULT_TOOLS: string[] = ['write_file', 'edit_file', 'read_file', 'smart_search', 'core_memory'];
+
+/**
+ * Get list of enabled tools from environment or defaults
+ */
+function getEnabledTools(): string[] | null {
+  const envTools = process.env.CCW_ENABLED_TOOLS;
+  if (envTools) {
+    // Support "all" to enable all tools
+    if (envTools.toLowerCase() === 'all') {
+      return null; // null means all tools
+    }
+    return envTools.split(',').map(t => t.trim()).filter(Boolean);
+  }
+  return DEFAULT_TOOLS;
+}
+
+/**
+ * Filter tools based on enabled list
+ */
+function filterTools(tools: ToolSchema[], enabledList: string[] | null): ToolSchema[] {
+  if (!enabledList) return tools; // null = all tools
+  return tools.filter(tool => enabledList.includes(tool.name));
+}
+
+/**
+ * Format tool result for display
+ */
+function formatToolResult(result: unknown): string {
+  if (result === null || result === undefined) {
+    return 'Tool completed successfully (no output)';
+  }
+
+  if (typeof result === 'string') {
+    return result;
+  }
+
+  if (typeof result === 'object') {
+    // Pretty print JSON with indentation
+    return JSON.stringify(result, null, 2);
+  }
+
+  return String(result);
+}
+
+/**
+ * Create and configure the MCP server
+ */
+function createServer(): Server {
+  const enabledTools = getEnabledTools();
+
+  const server = new Server(
+    {
+      name: SERVER_NAME,
+      version: SERVER_VERSION,
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  /**
+   * Handler for tools/list - Returns enabled CCW tools
+   */
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const allTools = getAllToolSchemas().filter((tool): tool is ToolSchema => tool !== null);
+    const tools = filterTools(allTools, enabledTools);
+    return { tools };
+  });
+
+  /**
+   * Handler for tools/call - Executes a CCW tool
+   */
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    // Check if tool is enabled
+    if (enabledTools && !enabledTools.includes(name)) {
+      return {
+        content: [{ type: 'text' as const, text: `Tool "${name}" is not enabled` }],
+        isError: true,
+      };
+    }
+
+    try {
+      // For smart_search init action, use progress-aware execution
+      const isInitAction = name === 'smart_search' && args?.action === 'init';
+
+      let result: ToolResult;
+      if (isInitAction) {
+        // Execute with progress callback that writes to stderr
+        result = await executeToolWithProgress(name, args || {}, (progress) => {
+          // Output progress to stderr (visible in terminal, doesn't interfere with JSON-RPC)
+          console.error(`[Progress] ${progress.percent}% - ${progress.message}`);
+        });
+      } else {
+        result = await executeTool(name, args || {});
+      }
+
+      if (!result.success) {
+        return {
+          content: [{ type: 'text' as const, text: `Error: ${result.error}` }],
+          isError: true,
+        };
+      }
+
+      return {
+        content: [{ type: 'text' as const, text: formatToolResult(result.result) }],
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: 'text' as const, text: `Tool execution failed: ${errorMessage}` }],
+        isError: true,
+      };
+    }
+  });
+
+  return server;
+}
+
+/**
+ * Main server execution
+ */
+async function main(): Promise<void> {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+
+  // Connect server to transport
+  await server.connect(transport);
+
+  // Error handling
+  process.on('SIGINT', async () => {
+    await server.close();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', async () => {
+    await server.close();
+    process.exit(0);
+  });
+
+  // Log server start (to stderr to not interfere with stdio protocol)
+  const projectRoot = getProjectRoot();
+  const allowedDirs = getAllowedDirectories();
+  console.error(`${SERVER_NAME} v${SERVER_VERSION} started`);
+  console.error(`Project root: ${projectRoot}`);
+  console.error(`Allowed directories: ${allowedDirs.join(', ')}`);
+  if (!process.env[ENV_PROJECT_ROOT]) {
+    console.error(`[Warning] ${ENV_PROJECT_ROOT} not set, using process.cwd()`);
+    console.error(`[Tip] Set ${ENV_PROJECT_ROOT} in your MCP config to specify project directory`);
+  }
+}
+
+// Run server
+main().catch((error: unknown) => {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  console.error('Server error:', errorMessage);
+  process.exit(1);
+});

package/src/templates/assets/css/github-dark.min.css

@@ -0,0 +1,10 @@
+pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}/*!
+  Theme: GitHub Dark
+  Description: Dark theme as seen on github.com
+  Author: github.com
+  Maintainer: @Hirse
+  Updated: 2021-05-15
+
+  Outdated base version: https://github.com/primer/github-syntax-dark
+  Current colors taken from GitHub's CSS
+*/.hljs{color:#c9d1d9;background:#0d1117}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#ff7b72}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#d2a8ff}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-variable{color:#79c0ff}.hljs-meta .hljs-string,.hljs-regexp,.hljs-string{color:#a5d6ff}.hljs-built_in,.hljs-symbol{color:#ffa657}.hljs-code,.hljs-comment,.hljs-formula{color:#8b949e}.hljs-name,.hljs-quote,.hljs-selector-pseudo,.hljs-selector-tag{color:#7ee787}.hljs-subst{color:#c9d1d9}.hljs-section{color:#1f6feb;font-weight:700}.hljs-bullet{color:#f2cc60}.hljs-emphasis{color:#c9d1d9;font-style:italic}.hljs-strong{color:#c9d1d9;font-weight:700}.hljs-addition{color:#aff5b4;background-color:#033a16}.hljs-deletion{color:#ffdcd7;background-color:#67060c}

package/src/templates/assets/css/github.min.css

@@ -0,0 +1,10 @@
+pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}/*!
+  Theme: GitHub
+  Description: Light theme as seen on github.com
+  Author: github.com
+  Maintainer: @Hirse
+  Updated: 2021-05-15
+
+  Outdated base version: https://github.com/primer/github-syntax-light
+  Current colors taken from GitHub's CSS
+*/.hljs{color:#24292e;background:#fff}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#d73a49}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#6f42c1}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-variable{color:#005cc5}.hljs-meta .hljs-string,.hljs-regexp,.hljs-string{color:#032f62}.hljs-built_in,.hljs-symbol{color:#e36209}.hljs-code,.hljs-comment,.hljs-formula{color:#6a737d}.hljs-name,.hljs-quote,.hljs-selector-pseudo,.hljs-selector-tag{color:#22863a}.hljs-subst{color:#24292e}.hljs-section{color:#005cc5;font-weight:700}.hljs-bullet{color:#735c0f}.hljs-emphasis{color:#24292e;font-style:italic}.hljs-strong{color:#24292e;font-weight:700}.hljs-addition{color:#22863a;background-color:#f0fff4}.hljs-deletion{color:#b31d28;background-color:#ffeef0}