Deploying DailyTxt

DailyTxt is a minimalist, privacy-focused daily journaling application that stores your entries as plain text files. Built with simplicity and data ownership in mind, DailyTxt provides a clean web interface for capturing daily thoughts, experiences, and reflections while keeping your data in an accessible, portable format. Unlike traditional journaling platforms that lock your content in proprietary databases, DailyTxt maintains your entries as Markdown files that you can easily backup, search, and migrate.

The application emphasizes speed and distraction-free writing with features like calendar navigation, full-text search, markdown rendering, and automatic daily file organization. DailyTxt is perfect for individuals who want a lightweight journaling solution without the bloat of feature-heavy alternatives, making it an excellent choice for personal knowledge management, daily logging, or creative writing practice.

Why Deploy DailyTxt on Klutch.sh?

Deploying DailyTxt on Klutch.sh offers several advantages for running your private journaling platform:

Automatic Docker Detection: Klutch.sh automatically recognizes your Dockerfile and handles the containerization process without manual configuration
Persistent Storage: Built-in volume management ensures your journal entries and configuration files are safely preserved across deployments and container restarts
Privacy-First Hosting: Keep your personal journal entries on infrastructure you control, with no third-party access to your private thoughts
Simple HTTP Routing: Klutch.sh’s HTTP traffic handling provides immediate HTTPS access to your journaling interface with automatic SSL certificate provisioning
Rapid Deployment: Go from code to production in minutes with GitHub integration and automated deployment pipelines
Resource Efficiency: DailyTxt’s lightweight architecture makes it cost-effective to host on Klutch.sh’s containerized infrastructure
Data Portability: Access your plain text journal files directly through the persistent volume for easy backup and migration

Prerequisites

Before deploying DailyTxt to Klutch.sh, ensure you have:

A Klutch.sh account (sign up at klutch.sh)
A GitHub account with a repository for your DailyTxt deployment
Basic understanding of Docker and containerization concepts
Familiarity with environment variables and web application configuration
Git installed on your local development machine

Understanding DailyTxt Architecture

DailyTxt follows a straightforward architecture designed for simplicity and data ownership:

Core Components

Web Server The application uses a lightweight Node.js Express server that handles HTTP requests, serves the journaling interface, and manages file operations. The server provides RESTful API endpoints for creating, reading, updating, and deleting journal entries while maintaining minimal dependencies.

File Storage System Journal entries are stored as individual Markdown files organized by date (e.g., 2025-12-05.md). This file-based approach ensures data portability, human-readable backups, and easy migration without database lock-in. Each file contains the full text of your daily entry with optional YAML frontmatter for metadata.

Markdown Processor DailyTxt includes a markdown rendering engine that converts your plain text entries into formatted HTML for reading. This supports standard markdown syntax including headers, lists, links, code blocks, and emphasis, allowing you to structure your journal entries with rich formatting.

Search Engine The application features full-text search functionality that indexes your journal entries for quick retrieval. Search queries scan through all your markdown files, returning relevant results with context snippets and date references.

Calendar Interface A built-in calendar view provides visual navigation through your journaling history. The calendar highlights days with entries, displays entry counts, and enables quick access to any date’s journal content.

Data Flow

User accesses the web interface through their browser
Express server authenticates the request (if authentication is enabled)
Application retrieves or creates markdown files from the persistent storage directory
Markdown content is rendered to HTML for display
User edits or creates journal entries through the web interface
Changes are written directly to markdown files on disk
Search indexes are updated to include new content

Storage Requirements

DailyTxt requires persistent storage to maintain your journal entries across container restarts:

Journal Directory: Stores all markdown files organized by date (typically /app/data/journal)
Configuration Files: Maintains application settings and user preferences (typically /app/data/config)
Search Indexes: Caches full-text search indexes for improved query performance

Installation and Setup

Let’s walk through setting up DailyTxt for deployment on Klutch.sh.

Step 1: Create the Project Structure

First, create a new directory for your DailyTxt deployment:

mkdir dailytxt-deployment
cd dailytxt-deployment
git init

Step 2: Create the Application Code

Create the main server file server.js:

const express = require('express');
const fs = require('fs').promises;
const path = require('path');
const marked = require('marked');
const matter = require('gray-matter');

const app = express();
const PORT = process.env.PORT || 3000;
const DATA_DIR = process.env.DATA_DIR || '/app/data/journal';
const PASSWORD = process.env.PASSWORD || '';

app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(express.static('public'));

// Session management
const sessions = new Map();

function generateSessionId() {
  return Math.random().toString(36).substring(2) + Date.now().toString(36);
}

function isAuthenticated(req) {
  if (!PASSWORD) return true; // No password required
  const sessionId = req.headers['x-session-id'];
  return sessions.has(sessionId);
}

// Ensure data directory exists
async function ensureDataDir() {
  try {
    await fs.mkdir(DATA_DIR, { recursive: true });
    console.log(`Data directory ready: ${DATA_DIR}`);
  } catch (error) {
    console.error('Failed to create data directory:', error);
  }
}

// Authentication endpoint
app.post('/api/auth/login', async (req, res) => {
  const { password } = req.body;

  if (!PASSWORD || password === PASSWORD) {
    const sessionId = generateSessionId();
    sessions.set(sessionId, { createdAt: Date.now() });
    res.json({ success: true, sessionId });
  } else {
    res.status(401).json({ success: false, message: 'Invalid password' });
  }
});

app.post('/api/auth/logout', (req, res) => {
  const sessionId = req.headers['x-session-id'];
  sessions.delete(sessionId);
  res.json({ success: true });
});

app.get('/api/auth/check', (req, res) => {
  res.json({
    authenticated: isAuthenticated(req),
    requiresAuth: !!PASSWORD
  });
});

// Get entry for a specific date
app.get('/api/entries/:date', async (req, res) => {
  if (!isAuthenticated(req)) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  const { date } = req.params;
  const filename = `${date}.md`;
  const filepath = path.join(DATA_DIR, filename);

  try {
    const content = await fs.readFile(filepath, 'utf-8');
    const parsed = matter(content);

    res.json({
      date,
      content: parsed.content,
      metadata: parsed.data,
      html: marked.parse(parsed.content)
    });
  } catch (error) {
    if (error.code === 'ENOENT') {
      res.json({ date, content: '', metadata: {}, html: '' });
    } else {
      console.error('Error reading entry:', error);
      res.status(500).json({ error: 'Failed to read entry' });
    }
  }
});

// Save entry for a specific date
app.post('/api/entries/:date', async (req, res) => {
  if (!isAuthenticated(req)) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  const { date } = req.params;
  const { content, metadata = {} } = req.body;
  const filename = `${date}.md`;
  const filepath = path.join(DATA_DIR, filename);

  try {
    let fileContent = content;

    // Add frontmatter if metadata exists
    if (Object.keys(metadata).length > 0) {
      fileContent = matter.stringify(content, metadata);
    }

    await fs.writeFile(filepath, fileContent, 'utf-8');

    res.json({
      success: true,
      date,
      html: marked.parse(content)
    });
  } catch (error) {
    console.error('Error saving entry:', error);
    res.status(500).json({ error: 'Failed to save entry' });
  }
});

// Delete entry for a specific date
app.delete('/api/entries/:date', async (req, res) => {
  if (!isAuthenticated(req)) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  const { date } = req.params;
  const filename = `${date}.md`;
  const filepath = path.join(DATA_DIR, filename);

  try {
    await fs.unlink(filepath);
    res.json({ success: true });
  } catch (error) {
    if (error.code === 'ENOENT') {
      res.json({ success: true }); // Already deleted
    } else {
      console.error('Error deleting entry:', error);
      res.status(500).json({ error: 'Failed to delete entry' });
    }
  }
});

// List all entries
app.get('/api/entries', async (req, res) => {
  if (!isAuthenticated(req)) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  try {
    const files = await fs.readdir(DATA_DIR);
    const entries = [];

    for (const file of files) {
      if (file.endsWith('.md')) {
        const date = file.replace('.md', '');
        const filepath = path.join(DATA_DIR, file);
        const stats = await fs.stat(filepath);
        const content = await fs.readFile(filepath, 'utf-8');
        const parsed = matter(content);

        entries.push({
          date,
          wordCount: parsed.content.split(/\s+/).length,
          modified: stats.mtime,
          metadata: parsed.data
        });
      }
    }

    // Sort by date descending
    entries.sort((a, b) => b.date.localeCompare(a.date));

    res.json(entries);
  } catch (error) {
    console.error('Error listing entries:', error);
    res.status(500).json({ error: 'Failed to list entries' });
  }
});

// Search entries
app.get('/api/search', async (req, res) => {
  if (!isAuthenticated(req)) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  const { q } = req.query;

  if (!q) {
    return res.json([]);
  }

  try {
    const files = await fs.readdir(DATA_DIR);
    const results = [];
    const searchTerm = q.toLowerCase();

    for (const file of files) {
      if (file.endsWith('.md')) {
        const date = file.replace('.md', '');
        const filepath = path.join(DATA_DIR, file);
        const content = await fs.readFile(filepath, 'utf-8');
        const parsed = matter(content);

        if (parsed.content.toLowerCase().includes(searchTerm)) {
          // Find context around match
          const lowerContent = parsed.content.toLowerCase();
          const matchIndex = lowerContent.indexOf(searchTerm);
          const contextStart = Math.max(0, matchIndex - 50);
          const contextEnd = Math.min(parsed.content.length, matchIndex + searchTerm.length + 50);
          const context = parsed.content.slice(contextStart, contextEnd);

          results.push({
            date,
            context: '...' + context + '...',
            metadata: parsed.data
          });
        }
      }
    }

    results.sort((a, b) => b.date.localeCompare(a.date));
    res.json(results);
  } catch (error) {
    console.error('Error searching entries:', error);
    res.status(500).json({ error: 'Failed to search entries' });
  }
});

// Get statistics
app.get('/api/stats', async (req, res) => {
  if (!isAuthenticated(req)) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  try {
    const files = await fs.readdir(DATA_DIR);
    let totalWords = 0;
    let totalEntries = 0;
    const entriesByMonth = {};

    for (const file of files) {
      if (file.endsWith('.md')) {
        totalEntries++;
        const date = file.replace('.md', '');
        const month = date.substring(0, 7); // YYYY-MM

        const filepath = path.join(DATA_DIR, file);
        const content = await fs.readFile(filepath, 'utf-8');
        const parsed = matter(content);
        const wordCount = parsed.content.split(/\s+/).length;

        totalWords += wordCount;

        if (!entriesByMonth[month]) {
          entriesByMonth[month] = { count: 0, words: 0 };
        }
        entriesByMonth[month].count++;
        entriesByMonth[month].words += wordCount;
      }
    }

    res.json({
      totalEntries,
      totalWords,
      averageWordsPerEntry: totalEntries > 0 ? Math.round(totalWords / totalEntries) : 0,
      entriesByMonth
    });
  } catch (error) {
    console.error('Error calculating stats:', error);
    res.status(500).json({ error: 'Failed to calculate stats' });
  }
});

// Health check
app.get('/health', (req, res) => {
  res.json({ status: 'ok', timestamp: new Date().toISOString() });
});

// Initialize and start server
async function start() {
  await ensureDataDir();

  app.listen(PORT, '0.0.0.0', () => {
    console.log(`DailyTxt server running on port ${PORT}`);
    console.log(`Data directory: ${DATA_DIR}`);
    console.log(`Authentication: ${PASSWORD ? 'enabled' : 'disabled'}`);
  });
}

start().catch(console.error);

Step 3: Create the Frontend Interface

Create a public directory and add index.html:

mkdir public

Create public/index.html:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>DailyTxt - Your Daily Journal</title>
  <style>
    * {
      margin: 0;
      padding: 0;
      box-sizing: border-box;
    }

    body {
      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
      line-height: 1.6;
      color: #333;
      background: #f5f5f5;
    }

    .container {
      max-width: 900px;
      margin: 0 auto;
      padding: 20px;
    }

    header {
      background: white;
      padding: 20px;
      border-radius: 8px;
      margin-bottom: 20px;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
    }

    h1 {
      font-size: 28px;
      margin-bottom: 10px;
      color: #2c3e50;
    }

    .auth-container {
      background: white;
      padding: 40px;
      border-radius: 8px;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
      max-width: 400px;
      margin: 100px auto;
    }

    .controls {
      display: flex;
      gap: 10px;
      flex-wrap: wrap;
      align-items: center;
      margin-bottom: 20px;
    }

    .date-nav {
      display: flex;
      gap: 5px;
      align-items: center;
    }

    button {
      padding: 8px 16px;
      background: #3498db;
      color: white;
      border: none;
      border-radius: 4px;
      cursor: pointer;
      font-size: 14px;
      transition: background 0.2s;
    }

    button:hover {
      background: #2980b9;
    }

    button.secondary {
      background: #95a5a6;
    }

    button.secondary:hover {
      background: #7f8c8d;
    }

    button.danger {
      background: #e74c3c;
    }

    button.danger:hover {
      background: #c0392b;
    }

    input[type="date"],
    input[type="text"],
    input[type="password"] {
      padding: 8px 12px;
      border: 1px solid #ddd;
      border-radius: 4px;
      font-size: 14px;
    }

    input[type="text"] {
      flex: 1;
      min-width: 200px;
    }

    .editor-container {
      background: white;
      padding: 20px;
      border-radius: 8px;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
      margin-bottom: 20px;
    }

    .current-date {
      font-size: 18px;
      font-weight: 600;
      color: #2c3e50;
      margin-bottom: 15px;
      padding-bottom: 10px;
      border-bottom: 2px solid #3498db;
    }

    textarea {
      width: 100%;
      min-height: 400px;
      padding: 15px;
      border: 1px solid #ddd;
      border-radius: 4px;
      font-size: 16px;
      font-family: 'Courier New', monospace;
      resize: vertical;
      line-height: 1.8;
    }

    textarea:focus {
      outline: none;
      border-color: #3498db;
    }

    .preview {
      background: white;
      padding: 20px;
      border-radius: 8px;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
      margin-bottom: 20px;
    }

    .preview h2 {
      margin-top: 20px;
      margin-bottom: 10px;
      color: #2c3e50;
    }

    .preview p {
      margin-bottom: 15px;
    }

    .preview ul, .preview ol {
      margin-left: 30px;
      margin-bottom: 15px;
    }

    .preview code {
      background: #f4f4f4;
      padding: 2px 6px;
      border-radius: 3px;
      font-family: 'Courier New', monospace;
    }

    .preview pre {
      background: #f4f4f4;
      padding: 15px;
      border-radius: 4px;
      overflow-x: auto;
      margin-bottom: 15px;
    }

    .stats {
      display: flex;
      gap: 15px;
      margin-bottom: 20px;
      flex-wrap: wrap;
    }

    .stat-card {
      background: white;
      padding: 15px;
      border-radius: 8px;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
      flex: 1;
      min-width: 150px;
    }

    .stat-value {
      font-size: 28px;
      font-weight: 700;
      color: #3498db;
    }

    .stat-label {
      font-size: 12px;
      color: #7f8c8d;
      text-transform: uppercase;
    }

    .entries-list {
      background: white;
      padding: 20px;
      border-radius: 8px;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
    }

    .entry-item {
      padding: 12px;
      border-bottom: 1px solid #eee;
      cursor: pointer;
      transition: background 0.2s;
    }

    .entry-item:hover {
      background: #f8f9fa;
    }

    .entry-date {
      font-weight: 600;
      color: #2c3e50;
    }

    .entry-meta {
      font-size: 12px;
      color: #7f8c8d;
    }

    .search-results {
      background: white;
      padding: 20px;
      border-radius: 8px;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
      margin-bottom: 20px;
    }

    .search-result {
      padding: 12px;
      border-bottom: 1px solid #eee;
      cursor: pointer;
    }

    .search-result:hover {
      background: #f8f9fa;
    }

    .hidden {
      display: none;
    }

    .word-count {
      color: #7f8c8d;
      font-size: 14px;
      margin-top: 10px;
    }

    .save-indicator {
      color: #27ae60;
      font-size: 14px;
      margin-left: 10px;
    }

    footer {
      text-align: center;
      padding: 20px;
      color: #7f8c8d;
      font-size: 14px;
    }
  </style>
</head>
<body>
  <div id="authContainer" class="auth-container hidden">
    <h1>DailyTxt Login</h1>
    <p style="margin: 20px 0;">Enter your password to access your journal</p>
    <input type="password" id="passwordInput" placeholder="Password" style="width: 100%; margin-bottom: 10px;">
    <button onclick="login()" style="width: 100%;">Login</button>
    <p id="authError" style="color: #e74c3c; margin-top: 10px;"></p>
  </div>

  <div id="appContainer" class="hidden">
    <div class="container">
      <header>
        <h1>📝 DailyTxt</h1>
        <p>Your private daily journal</p>
      </header>

      <div class="controls">
        <div class="date-nav">
          <button onclick="changeDate(-1)">← Previous</button>
          <input type="date" id="dateInput" onchange="loadEntry()">
          <button onclick="changeDate(1)">Next →</button>
          <button onclick="goToToday()">Today</button>
        </div>
        <input type="text" id="searchInput" placeholder="Search entries..." onkeyup="handleSearch(event)">
        <button onclick="searchEntries()">Search</button>
        <button class="secondary" onclick="showStats()">Stats</button>
        <button class="secondary" onclick="toggleView()">Toggle View</button>
        <button class="danger" onclick="logout()">Logout</button>
      </div>

      <div id="searchResults" class="search-results hidden"></div>

      <div id="statsContainer" class="hidden">
        <div class="stats" id="statsDisplay"></div>
        <div class="entries-list">
          <h2>All Entries</h2>
          <div id="entriesList"></div>
        </div>
      </div>

      <div id="editorView">
        <div class="editor-container">
          <div class="current-date" id="currentDate"></div>
          <textarea id="entryContent" placeholder="What's on your mind today?"></textarea>
          <div class="word-count">
            <span id="wordCount">0 words</span>
            <span class="save-indicator" id="saveIndicator"></span>
          </div>
          <div style="margin-top: 15px; display: flex; gap: 10px;">
            <button onclick="saveEntry()">💾 Save</button>
            <button class="danger" onclick="deleteEntry()">🗑️ Delete</button>
          </div>
        </div>

        <div class="preview hidden" id="previewContainer">
          <h2>Preview</h2>
          <div id="preview"></div>
        </div>
      </div>

      <footer>
        <p>DailyTxt - Simple, private journaling</p>
      </footer>
    </div>
  </div>

  <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
  <script>
    let sessionId = localStorage.getItem('sessionId');
    let currentDate = new Date().toISOString().split('T')[0];
    let showPreview = false;
    let autoSaveTimeout = null;

    // Initialize
    async function init() {
      const authCheck = await fetch('/api/auth/check', {
        headers: sessionId ? { 'X-Session-Id': sessionId } : {}
      }).then(r => r.json());

      if (authCheck.requiresAuth && !authCheck.authenticated) {
        document.getElementById('authContainer').classList.remove('hidden');
        document.getElementById('appContainer').classList.add('hidden');
      } else {
        document.getElementById('authContainer').classList.add('hidden');
        document.getElementById('appContainer').classList.remove('hidden');
        document.getElementById('dateInput').value = currentDate;
        await loadEntry();
      }
    }

    async function login() {
      const password = document.getElementById('passwordInput').value;
      const response = await fetch('/api/auth/login', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ password })
      }).then(r => r.json());

      if (response.success) {
        sessionId = response.sessionId;
        localStorage.setItem('sessionId', sessionId);
        init();
      } else {
        document.getElementById('authError').textContent = 'Invalid password';
      }
    }

    async function logout() {
      await fetch('/api/auth/logout', {
        method: 'POST',
        headers: { 'X-Session-Id': sessionId }
      });
      localStorage.removeItem('sessionId');
      sessionId = null;
      init();
    }

    async function loadEntry() {
      currentDate = document.getElementById('dateInput').value;
      const response = await fetch(`/api/entries/${currentDate}`, {
        headers: { 'X-Session-Id': sessionId }
      }).then(r => r.json());

      document.getElementById('entryContent').value = response.content || '';
      document.getElementById('currentDate').textContent = formatDate(currentDate);
      updateWordCount();

      if (showPreview) {
        updatePreview();
      }
    }

    async function saveEntry() {
      const content = document.getElementById('entryContent').value;

      await fetch(`/api/entries/${currentDate}`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'X-Session-Id': sessionId
        },
        body: JSON.stringify({ content })
      });

      showSaveIndicator();
    }

    async function deleteEntry() {
      if (!confirm('Are you sure you want to delete this entry?')) return;

      await fetch(`/api/entries/${currentDate}`, {
        method: 'DELETE',
        headers: { 'X-Session-Id': sessionId }
      });

      document.getElementById('entryContent').value = '';
      updateWordCount();
    }

    function changeDate(days) {
      const date = new Date(currentDate);
      date.setDate(date.getDate() + days);
      currentDate = date.toISOString().split('T')[0];
      document.getElementById('dateInput').value = currentDate;
      loadEntry();
    }

    function goToToday() {
      currentDate = new Date().toISOString().split('T')[0];
      document.getElementById('dateInput').value = currentDate;
      loadEntry();
    }

    function toggleView() {
      showPreview = !showPreview;
      const preview = document.getElementById('previewContainer');

      if (showPreview) {
        preview.classList.remove('hidden');
        updatePreview();
      } else {
        preview.classList.add('hidden');
      }
    }

    function updatePreview() {
      const content = document.getElementById('entryContent').value;
      document.getElementById('preview').innerHTML = marked.parse(content);
    }

    function updateWordCount() {
      const content = document.getElementById('entryContent').value;
      const words = content.trim().split(/\s+/).filter(w => w.length > 0).length;
      document.getElementById('wordCount').textContent = `${words} words`;
    }

    function showSaveIndicator() {
      const indicator = document.getElementById('saveIndicator');
      indicator.textContent = '✓ Saved';
      setTimeout(() => {
        indicator.textContent = '';
      }, 2000);
    }

    function formatDate(dateStr) {
      const date = new Date(dateStr + 'T00:00:00');
      return date.toLocaleDateString('en-US', {
        weekday: 'long',
        year: 'numeric',
        month: 'long',
        day: 'numeric'
      });
    }

    async function searchEntries() {
      const query = document.getElementById('searchInput').value;
      if (!query) return;

      const results = await fetch(`/api/search?q=${encodeURIComponent(query)}`, {
        headers: { 'X-Session-Id': sessionId }
      }).then(r => r.json());

      const container = document.getElementById('searchResults');

      if (results.length === 0) {
        container.innerHTML = '<p>No results found</p>';
      } else {
        container.innerHTML = `
          <h3>Search Results (${results.length})</h3>
          ${results.map(r => `
            <div class="search-result" onclick="loadDate('${r.date}')">
              <div class="entry-date">${formatDate(r.date)}</div>
              <div style="margin-top: 5px; color: #666;">${r.context}</div>
            </div>
          `).join('')}
        `;
      }

      container.classList.remove('hidden');
      document.getElementById('statsContainer').classList.add('hidden');
    }

    function handleSearch(event) {
      if (event.key === 'Enter') {
        searchEntries();
      }
    }

    function loadDate(date) {
      currentDate = date;
      document.getElementById('dateInput').value = date;
      document.getElementById('searchResults').classList.add('hidden');
      document.getElementById('statsContainer').classList.add('hidden');
      loadEntry();
    }

    async function showStats() {
      const [stats, entries] = await Promise.all([
        fetch('/api/stats', { headers: { 'X-Session-Id': sessionId } }).then(r => r.json()),
        fetch('/api/entries', { headers: { 'X-Session-Id': sessionId } }).then(r => r.json())
      ]);

      document.getElementById('statsDisplay').innerHTML = `
        <div class="stat-card">
          <div class="stat-value">${stats.totalEntries}</div>
          <div class="stat-label">Total Entries</div>
        </div>
        <div class="stat-card">
          <div class="stat-value">${stats.totalWords.toLocaleString()}</div>
          <div class="stat-label">Total Words</div>
        </div>
        <div class="stat-card">
          <div class="stat-value">${stats.averageWordsPerEntry}</div>
          <div class="stat-label">Avg Words/Entry</div>
        </div>
      `;

      document.getElementById('entriesList').innerHTML = entries.map(e => `
        <div class="entry-item" onclick="loadDate('${e.date}')">
          <div class="entry-date">${formatDate(e.date)}</div>
          <div class="entry-meta">${e.wordCount} words</div>
        </div>
      `).join('');

      document.getElementById('searchResults').classList.add('hidden');
      document.getElementById('statsContainer').classList.remove('hidden');
    }

    // Auto-save on typing
    document.getElementById('entryContent')?.addEventListener('input', () => {
      updateWordCount();

      clearTimeout(autoSaveTimeout);
      autoSaveTimeout = setTimeout(() => {
        saveEntry();
      }, 3000);
    });

    // Initialize app
    init();
  </script>
</body>
</html>

Step 4: Create package.json

Create the package.json file with the required dependencies:

{
  "name": "dailytxt",
  "version": "1.0.0",
  "description": "Minimalist daily journaling application",
  "main": "server.js",
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js"
  },
  "keywords": ["journal", "diary", "markdown", "notes"],
  "author": "",
  "license": "MIT",
  "dependencies": {
    "express": "^4.18.2",
    "marked": "^11.0.0",
    "gray-matter": "^4.0.3"
  },
  "devDependencies": {
    "nodemon": "^3.0.2"
  },
  "engines": {
    "node": ">=18.0.0"
  }
}

Step 5: Create the Dockerfile

Create a Dockerfile in the root directory:

FROM node:18-alpine

# Set working directory
WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application files
COPY server.js ./
COPY public ./public

# Create data directory
RUN mkdir -p /app/data/journal

# Expose port
EXPOSE 3000

# Set environment variables
ENV NODE_ENV=production
ENV PORT=3000
ENV DATA_DIR=/app/data/journal

# Start application
CMD ["node", "server.js"]

Step 6: Create .dockerignore

Create a .dockerignore file to optimize the build:

node_modules
npm-debug.log
.git
.gitignore
README.md
.env
*.md

Step 7: Create Environment Configuration

Create a .env.example file for reference:

# Server Configuration
PORT=3000
DATA_DIR=/app/data/journal

# Authentication (optional - leave empty to disable)
PASSWORD=

# Node Environment
NODE_ENV=production

Step 8: Initialize Git Repository

git add .
git commit -m "Initial DailyTxt setup"
git branch -M master
git remote add origin https://github.com/yourusername/dailytxt-deployment.git
git push -u origin master

Deploying to Klutch.sh

Now that your DailyTxt application is configured, let’s deploy it to Klutch.sh.

Log in to Klutch.sh
Navigate to klutch.sh/app and sign in with your GitHub account.
Create a New Project
Click “New Project” and select “Import from GitHub”. Choose the repository containing your DailyTxt deployment.
Configure Build Settings
Klutch.sh will automatically detect the Dockerfile in your repository. The platform will use this for building your container.
Configure Traffic Settings
Select “HTTP” as the traffic type. DailyTxt serves a web interface on port 3000, and Klutch.sh will automatically route HTTPS traffic to this port.
Set Environment Variables
In the project settings, add the following environment variables:
- PORT: 3000
- DATA_DIR: /app/data/journal
- PASSWORD: Your chosen password (optional but recommended for privacy)
- NODE_ENV: production
Configure Persistent Storage
DailyTxt requires persistent storage to maintain your journal entries:
- Click "Add Volume" in the Storage section
- Set the mount path to /app/data
- Allocate at least 1GB for storage (adjust based on expected journal size)
This ensures your journal entries persist across deployments and container restarts.
Deploy the Application
Click “Deploy” to start the build process. Klutch.sh will:
- Clone your repository
- Build the Docker image using your Dockerfile
- Deploy the container with the specified configuration
- Provision an HTTPS endpoint
Access Your Journal
Once deployment completes, Klutch.sh will provide a URL like example-app.klutch.sh. Visit this URL to access your DailyTxt journal.
Verify Persistent Storage
Create a test entry and then trigger a redeployment. Your entries should persist, confirming that the volume is correctly mounted.

Getting Started with DailyTxt

Once your DailyTxt instance is deployed, here’s how to use it effectively:

Navigate to your deployed URL
If you set a PASSWORD environment variable, enter it to authenticate
You’ll see the journal interface with today’s date selected

Creating Your First Entry

The editor automatically loads today’s date
Start typing in the textarea - your entry supports Markdown formatting
Click ”💾 Save” to persist your entry (or wait 3 seconds for auto-save)
Use Markdown syntax for formatting:

# Today's Highlights

Had a productive morning working on the new project. Key accomplishments:

- Completed the authentication system
- Fixed three critical bugs
- Reviewed 5 pull requests

## Goals for Tomorrow

1. Deploy to production
2. Write documentation
3. Plan next sprint

**Mood**: 😊 Energized and focused

> "The secret of getting ahead is getting started." - Mark Twain

Navigating Between Dates

Use the date navigation controls to browse your journal history:

← Previous / Next →: Move backward or forward one day
Date picker: Jump to any specific date
Today button: Return to today’s entry

Searching Your Journal

Enter search terms in the search box
Press Enter or click “Search”
Results show matching entries with context snippets
Click any result to load that day’s entry

Viewing Statistics

Click “Stats” to see your journaling analytics:

Total Entries: How many days you’ve journaled
Total Words: Cumulative word count across all entries
Average Words/Entry: Mean entry length
Entries List: Chronological list of all entries with word counts

Using Markdown Preview

Click “Toggle View” to show the preview panel
See your Markdown rendered as formatted HTML
Preview updates automatically as you type
Toggle again to hide the preview

Managing Entries

Auto-save: Entries automatically save 3 seconds after you stop typing
Manual Save: Click ”💾 Save” to save immediately
Delete: Click “🗑️ Delete” to remove the current entry (requires confirmation)
Word Count: Track your writing progress with the live word counter

Production Best Practices

To run DailyTxt effectively in production on Klutch.sh, follow these recommendations:

Security Configuration

Enable Password Protection Set a strong PASSWORD environment variable to protect your journal from unauthorized access. Use a password manager to generate and store a secure passphrase:

PASSWORD=your-secure-password-here

Use HTTPS Only Klutch.sh automatically provisions SSL certificates, ensuring all communication with your journal is encrypted. Never access your journal over unencrypted connections.

Regular Password Rotation Periodically update your PASSWORD environment variable through the Klutch.sh dashboard, especially if you suspect unauthorized access.

Session Management Sessions are stored in memory by default. For production deployments expecting multiple users or longer sessions, consider implementing Redis-based session storage.

Storage Management

Volume Sizing Estimate your storage needs based on writing frequency:

Light journaling (1-2 times/week, 200 words): 500MB sufficient for years
Regular journaling (daily, 500 words): 1GB recommended
Heavy journaling (daily, 1000+ words): 2-5GB for extensive archives

Backup Strategy Implement regular backups of your journal data:

Use Klutch.sh volume snapshots for point-in-time recovery
Periodically download your markdown files through SFTP or volume access
Store backups in secure, encrypted cloud storage
Test backup restoration procedures quarterly

File Organization Journal entries are stored as YYYY-MM-DD.md files. This format ensures:

Chronological sorting by filename
Easy manual navigation
Compatibility with static site generators
Simple migration to other platforms

Performance Optimization

Node.js Configuration For larger journals with thousands of entries, optimize Node.js settings:

ENV NODE_OPTIONS="--max-old-space-size=512"

Search Indexing The built-in search performs full-text scanning. For journals with 1000+ entries, consider implementing a search index:

Add a background indexing service
Use a lightweight search engine like MeiliSearch
Store indexes in the persistent volume

Caching Static Assets Enable browser caching for the frontend:

app.use(express.static('public', {
  maxAge: '1d',
  etag: true
}));

Monitoring and Maintenance

Health Checks The /health endpoint provides basic status monitoring. Configure Klutch.sh health checks to use this endpoint for automatic restart on failures.

Log Management Monitor application logs through the Klutch.sh dashboard:

Track authentication attempts
Monitor file system errors
Review search query patterns
Identify performance bottlenecks

Resource Monitoring Watch container resource usage:

CPU usage should remain low (< 10%) during normal operation
Memory usage typically under 128MB for small-to-medium journals
Disk I/O spikes during save operations are normal

Data Portability

Export Your Journal Your journal entries are stored as plain Markdown files. To export:

Access the Klutch.sh volume through SFTP or file browser
Download the /app/data/journal directory
All entries are readable in any text editor
Import into other markdown-based tools without conversion

Migration Planning If moving to another platform:

Copy all .md files from the journal directory
Preserve the YYYY-MM-DD.md naming convention
Metadata in frontmatter transfers to compatible systems
No database dumps or proprietary formats required

Compliance and Privacy

Data Sovereignty Your journal data resides on Klutch.sh infrastructure. Review their data residency options if you have specific geographic requirements.

GDPR Considerations If journaling personal information about others:

Document your data retention policy
Implement data deletion procedures
Consider access controls for sensitive entries
Maintain audit logs for data access

Content Backup for Legal Compliance Some professions require journaling for compliance. Ensure your backup strategy meets regulatory requirements for data retention and accessibility.

Troubleshooting

Here are solutions to common issues you might encounter with DailyTxt:

Authentication Issues

Problem: Cannot log in with correct password

Solutions:

Verify PASSWORD environment variable is set correctly in Klutch.sh dashboard
Check for trailing spaces or special characters in password
Clear browser cache and localStorage
Restart the application container

Problem: Session expires frequently

Solutions:

Sessions are memory-based and cleared on restart
Implement Redis session storage for persistence
Extend session timeout in server configuration

Entry Saving Problems

Problem: Entries not persisting after restart

Solutions:

Verify persistent volume is attached at /app/data
Check volume permissions: ls -la /app/data/journal
Ensure volume size isn’t exhausted
Review application logs for file system errors

Problem: Auto-save not working

Solutions:

Check browser console for JavaScript errors
Verify network connectivity to backend
Increase auto-save timeout if network is slow
Use manual save button as fallback

Search Functionality

Problem: Search returns no results for known entries

Solutions:

Verify search query matches actual content
Check for case sensitivity issues
Ensure journal directory is readable
Review logs for file access errors
Try searching for simpler terms

Problem: Search is slow with many entries

Solutions:

Optimize by implementing search indexing
Limit search to recent entries (e.g., last year)
Use more specific search terms
Consider upgrading container resources

File System Issues

Problem: Cannot write to journal directory

Solutions:

Check volume mount configuration in Klutch.sh
Verify mount path is /app/data or matches DATA_DIR
Ensure container has write permissions
Review Dockerfile USER directive

Problem: Disk space exhausted

Solutions:

Increase volume size in Klutch.sh dashboard
Archive old entries to separate storage
Implement entry compression for large journals
Clean up any temporary files

Performance Problems

Problem: Application slow to load entries

Solutions:

Check container resource allocation
Review file system performance
Implement entry pagination
Cache frequently accessed entries
Optimize markdown parsing

Problem: High memory usage

Solutions:

Restart the container to clear memory leaks
Implement garbage collection tuning
Reduce concurrent operations
Stream large entries instead of loading entirely

Preview and Rendering

Problem: Markdown preview not rendering correctly

Solutions:

Verify marked.js library loaded successfully
Check browser console for JavaScript errors
Update marked.js to latest version
Test with simplified markdown syntax

Problem: Special characters displaying incorrectly

Solutions:

Ensure UTF-8 encoding in file saves
Check HTML meta charset tag
Verify markdown processor supports Unicode
Test with different browsers

Docker and Deployment

Problem: Container fails to start on Klutch.sh

Solutions:

Review build logs for errors
Verify all dependencies installed correctly
Check Dockerfile syntax and layer efficiency
Ensure Node.js version compatibility

Problem: Port binding errors

Solutions:

Confirm PORT environment variable is 3000
Verify no port conflicts in container
Check Klutch.sh HTTP traffic configuration
Review server.js port binding logic

Advanced Configuration

Take your DailyTxt deployment further with these advanced customization options:

Multi-User Support

For shared journaling or team documentation, implement user authentication:

// Add user-based directory structure
const getUserDir = (username) => {
  return path.join(DATA_DIR, username);
};

// Modify entry endpoints to use user-specific directories
app.get('/api/entries/:date', async (req, res) => {
  const username = req.session.username;
  const userDir = getUserDir(username);
  const filepath = path.join(userDir, `${req.params.date}.md`);
  // ... rest of implementation
});

Set environment variables for user management:

ENABLE_MULTI_USER=true
USER_DB_PATH=/app/data/users.json

Custom Themes

Implement theme switching for personalized aesthetics:

// Add theme selection to frontend
const themes = {
  light: { background: '#f5f5f5', text: '#333', primary: '#3498db' },
  dark: { background: '#1e1e1e', text: '#e0e0e0', primary: '#64b5f6' },
  sepia: { background: '#f4ecd8', text: '#5c4b37', primary: '#8b7355' }
};

// Store theme preference
localStorage.setItem('theme', 'dark');

Export Functionality

Add export capabilities for backup and archival:

// Export endpoint
app.get('/api/export', async (req, res) => {
  if (!isAuthenticated(req)) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  const format = req.query.format || 'zip';

  if (format === 'zip') {
    // Create ZIP archive of all entries
    const archiver = require('archiver');
    const archive = archiver('zip', { zlib: { level: 9 } });

    res.attachment('dailytxt-export.zip');
    archive.pipe(res);
    archive.directory(DATA_DIR, 'journal');
    await archive.finalize();
  } else if (format === 'json') {
    // Export as JSON
    const files = await fs.readdir(DATA_DIR);
    const entries = [];

    for (const file of files) {
      if (file.endsWith('.md')) {
        const content = await fs.readFile(path.join(DATA_DIR, file), 'utf-8');
        const parsed = matter(content);
        entries.push({
          date: file.replace('.md', ''),
          content: parsed.content,
          metadata: parsed.data
        });
      }
    }

    res.json(entries);
  }
});

Encryption at Rest

For sensitive journaling, implement file encryption:

const crypto = require('crypto');

const ENCRYPTION_KEY = process.env.ENCRYPTION_KEY;
const algorithm = 'aes-256-gcm';

function encrypt(text) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv(algorithm, Buffer.from(ENCRYPTION_KEY, 'hex'), iv);
  let encrypted = cipher.update(text, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  const authTag = cipher.getAuthTag();
  return iv.toString('hex') + ':' + authTag.toString('hex') + ':' + encrypted;
}

function decrypt(encrypted) {
  const parts = encrypted.split(':');
  const iv = Buffer.from(parts[0], 'hex');
  const authTag = Buffer.from(parts[1], 'hex');
  const encryptedText = parts[2];

  const decipher = crypto.createDecipheriv(algorithm, Buffer.from(ENCRYPTION_KEY, 'hex'), iv);
  decipher.setAuthTag(authTag);
  let decrypted = decipher.update(encryptedText, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  return decrypted;
}

Add environment variable:

ENCRYPTION_KEY=your-64-character-hex-key

Tag and Category System

Implement tagging for better organization:

// Add tags to entry metadata
app.post('/api/entries/:date', async (req, res) => {
  const { content, tags = [] } = req.body;
  const metadata = { tags, created: new Date().toISOString() };

  const fileContent = matter.stringify(content, metadata);
  await fs.writeFile(filepath, fileContent, 'utf-8');
  // ...
});

// Tag search endpoint
app.get('/api/tags/:tag', async (req, res) => {
  const { tag } = req.params;
  const files = await fs.readdir(DATA_DIR);
  const entries = [];

  for (const file of files) {
    const content = await fs.readFile(path.join(DATA_DIR, file), 'utf-8');
    const parsed = matter(content);

    if (parsed.data.tags && parsed.data.tags.includes(tag)) {
      entries.push({ date: file.replace('.md', ''), ...parsed });
    }
  }

  res.json(entries);
});

Notification System

Add reminders for consistent journaling:

const schedule = require('node-schedule');

// Daily reminder at 8 PM
const reminderJob = schedule.scheduleJob('0 20 * * *', async () => {
  const today = new Date().toISOString().split('T')[0];
  const filepath = path.join(DATA_DIR, `${today}.md`);

  try {
    await fs.access(filepath);
    // Entry exists - no reminder needed
  } catch {
    // Send notification (implement your notification method)
    console.log('Reminder: You haven\'t journaled today');
  }
});

API Rate Limiting

Protect your instance from abuse:

const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each IP to 100 requests per windowMs
  message: 'Too many requests, please try again later'
});

app.use('/api/', limiter);

Custom Entry Templates

Provide structured journaling templates:

app.get('/api/templates/:name', (req, res) => {
  const templates = {
    daily: `# Daily Journal\n\n## Gratitude\n- \n\n## Highlights\n- \n\n## Challenges\n- \n\n## Tomorrow's Goals\n- `,
    weekly: `# Weekly Review\n\n## Wins\n\n## Lessons Learned\n\n## Next Week Focus\n`,
    project: `# Project Log\n\n**Project**: \n**Status**: \n\n## Progress\n\n## Blockers\n\n## Next Steps\n`
  };

  res.json({ template: templates[req.params.name] || templates.daily });
});

Statistics Dashboard

Enhanced analytics for journal insights:

app.get('/api/analytics', async (req, res) => {
  const files = await fs.readdir(DATA_DIR);
  const analytics = {
    streak: 0,
    longestStreak: 0,
    totalDays: 0,
    entriesByDayOfWeek: {},
    entriesByMonth: {},
    wordCountTrend: []
  };

  // Calculate current streak
  let currentStreak = 0;
  const today = new Date();

  for (let i = 0; i < 365; i++) {
    const date = new Date(today);
    date.setDate(date.getDate() - i);
    const dateStr = date.toISOString().split('T')[0];

    if (files.includes(`${dateStr}.md`)) {
      currentStreak++;
    } else {
      break;
    }
  }

  analytics.streak = currentStreak;

  // More analytics calculations...

  res.json(analytics);
});

Additional Resources

Enhance your DailyTxt knowledge with these helpful resources:

Markdown Guide - Complete markdown syntax reference
Node.js Documentation - Node.js core documentation
Express.js Guide - Web framework documentation
Klutch.sh Documentation - Platform-specific deployment guides
Docker Resources - Containerization best practices
Marked.js - Markdown parsing library
Web Storage API - Browser storage for session management

Conclusion

DailyTxt provides a minimalist, privacy-focused solution for daily journaling with the freedom of plain text file storage. By deploying on Klutch.sh, you gain the benefits of containerized hosting with automatic HTTPS, persistent storage, and straightforward deployment workflows.

The file-based architecture ensures your journal entries remain portable and accessible, while the web interface provides a comfortable writing experience with markdown support, search functionality, and statistics tracking. With persistent volumes configured, your journal data persists safely across deployments and container updates.

Whether you’re maintaining a personal diary, documenting project progress, or building a knowledge base, DailyTxt on Klutch.sh offers a lightweight, maintainable solution that respects your data ownership. Start journaling today and build a valuable archive of your thoughts, experiences, and growth over time.

Deploying DailyTxt

Why Deploy DailyTxt on Klutch.sh?

Prerequisites

Understanding DailyTxt Architecture

Core Components

Data Flow

Storage Requirements

Installation and Setup

Step 1: Create the Project Structure

Step 2: Create the Application Code

Step 3: Create the Frontend Interface

Step 4: Create package.json

Step 5: Create the Dockerfile

Step 6: Create .dockerignore

Step 7: Create Environment Configuration

Step 8: Initialize Git Repository

Deploying to Klutch.sh

Getting Started with DailyTxt

First Login

Creating Your First Entry

Navigating Between Dates

Searching Your Journal

Viewing Statistics

Using Markdown Preview

Managing Entries

Production Best Practices

Security Configuration

Storage Management

Performance Optimization

Monitoring and Maintenance

Data Portability

Compliance and Privacy

Troubleshooting

Authentication Issues

Entry Saving Problems

Search Functionality

File System Issues

Performance Problems

Preview and Rendering

Docker and Deployment

Advanced Configuration

Multi-User Support

Custom Themes

Export Functionality

Encryption at Rest

Tag and Category System

Notification System

API Rate Limiting

Custom Entry Templates

Statistics Dashboard

Additional Resources

Conclusion