npm - trmnl-cli - Versions diffs - 0.1.0 - Mend

trmnl-cli 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/src/commands/send.ts ADDED Viewed

@@ -0,0 +1,115 @@
+/**
+ * trmnl send - Send content to TRMNL display
+ */
+import { readFileSync } from 'node:fs';
+import type { CAC } from 'cac';
+import { createPayload, formatValidation } from '../lib/validator.ts';
+import { sendToWebhook } from '../lib/webhook.ts';
+interface SendOptions {
+  content?: string;
+  file?: string;
+  plugin?: string;
+  webhook?: string;
+  skipValidation?: boolean;
+  skipLog?: boolean;
+  json?: boolean;
+}
+export function registerSendCommand(cli: CAC): void {
+  cli
+    .command('send', 'Send content to TRMNL display')
+    .option('-c, --content <html>', 'HTML content to send')
+    .option('-f, --file <path>', 'Read content from file')
+    .option('-p, --plugin <name>', 'Plugin to use (default: default plugin)')
+    .option('-w, --webhook <url>', 'Override webhook URL directly')
+    .option('--skip-validation', 'Skip payload validation')
+    .option('--skip-log', 'Skip history logging')
+    .option('--json', 'Output result as JSON')
+    .example('trmnl send --content "<div class=\\"layout\\">Hello</div>"')
+    .example('trmnl send --file ./output.html')
+    .example('trmnl send --file ./output.html --plugin office')
+    .example('echo \'{"merge_variables":{"content":"..."}}\' | trmnl send')
+    .action(async (options: SendOptions) => {
+      let content: string;
+      // Get content from options, file, or stdin
+      if (options.content) {
+        content = options.content;
+      } else if (options.file) {
+        try {
+          content = readFileSync(options.file, 'utf-8');
+        } catch (err) {
+          console.error(`Error reading file: ${options.file}`);
+          process.exit(1);
+        }
+      } else {
+        // Try reading from stdin
+        content = await readStdin();
+        if (!content) {
+          console.error('No content provided. Use --content, --file, or pipe content via stdin.');
+          process.exit(1);
+        }
+      }
+      // Create payload
+      const payload = createPayload(content);
+      // Send
+      const result = await sendToWebhook(payload, {
+        plugin: options.plugin,
+        webhookUrl: options.webhook,
+        skipValidation: options.skipValidation,
+        skipLog: options.skipLog,
+      });
+      // Output
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        if (result.success) {
+          console.log(`✓ Sent to TRMNL (${result.pluginName})`);
+          console.log(`  Status: ${result.statusCode}`);
+          console.log(`  Time: ${result.durationMs}ms`);
+          console.log(`  Size: ${result.validation.size_bytes} bytes (${result.validation.percent_used}% of limit)`);
+        } else {
+          console.error('✗ Failed to send');
+          console.error(`  Error: ${result.error}`);
+          if (result.pluginName) {
+            console.error(`  Plugin: ${result.pluginName}`);
+          }
+          console.log('');
+          console.log('Validation:');
+          console.log(formatValidation(result.validation));
+        }
+      }
+      process.exit(result.success ? 0 : 1);
+    });
+}
+/**
+ * Read content from stdin (non-blocking check)
+ */
+async function readStdin(): Promise<string> {
+  // Check if stdin has data (not a TTY)
+  if (process.stdin.isTTY) {
+    return '';
+  }
+  const chunks: Buffer[] = [];
+  return new Promise((resolve) => {
+    process.stdin.on('data', (chunk) => chunks.push(chunk));
+    process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8').trim()));
+    process.stdin.on('error', () => resolve(''));
+    // Timeout to avoid hanging
+    setTimeout(() => {
+      if (chunks.length === 0) {
+        resolve('');
+      }
+    }, 100);
+  });
+}

package/src/commands/validate.ts ADDED Viewed

@@ -0,0 +1,88 @@
+/**
+ * trmnl validate - Validate payload without sending
+ */
+import { readFileSync } from 'node:fs';
+import type { CAC } from 'cac';
+import { getTier } from '../lib/config.ts';
+import { createPayload, formatValidation, validatePayload } from '../lib/validator.ts';
+import type { WebhookTier } from '../types.ts';
+interface ValidateOptions {
+  content?: string;
+  file?: string;
+  tier?: WebhookTier;
+  json?: boolean;
+}
+export function registerValidateCommand(cli: CAC): void {
+  cli
+    .command('validate', 'Validate payload without sending')
+    .option('-c, --content <html>', 'HTML content to validate')
+    .option('-f, --file <path>', 'Read content from file')
+    .option('-t, --tier <tier>', 'Override tier (free or plus)')
+    .option('--json', 'Output result as JSON')
+    .example('trmnl validate --file ./output.html')
+    .example('trmnl validate --content "<div>...</div>" --tier plus')
+    .action(async (options: ValidateOptions) => {
+      let content: string;
+      // Get content from options, file, or stdin
+      if (options.content) {
+        content = options.content;
+      } else if (options.file) {
+        try {
+          content = readFileSync(options.file, 'utf-8');
+        } catch (err) {
+          console.error(`Error reading file: ${options.file}`);
+          process.exit(1);
+        }
+      } else {
+        // Try reading from stdin
+        content = await readStdin();
+        if (!content) {
+          console.error('No content provided. Use --content, --file, or pipe content via stdin.');
+          process.exit(1);
+        }
+      }
+      // Use explicit tier or global config
+      const tier = options.tier || getTier();
+      // Create payload and validate
+      const payload = createPayload(content);
+      const result = validatePayload(payload, tier);
+      // Output
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(formatValidation(result));
+      }
+      process.exit(result.valid ? 0 : 1);
+    });
+}
+/**
+ * Read content from stdin (non-blocking check)
+ */
+async function readStdin(): Promise<string> {
+  if (process.stdin.isTTY) {
+    return '';
+  }
+  const chunks: Buffer[] = [];
+  return new Promise((resolve) => {
+    process.stdin.on('data', (chunk) => chunks.push(chunk));
+    process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8').trim()));
+    process.stdin.on('error', () => resolve(''));
+    setTimeout(() => {
+      if (chunks.length === 0) {
+        resolve('');
+      }
+    }, 100);
+  });
+}

package/src/index.ts ADDED Viewed

@@ -0,0 +1,38 @@
+#!/usr/bin/env bun
+/**
+ * trmnl-cli - CLI tool for TRMNL e-ink displays
+ *
+ * Commands:
+ *   trmnl send       - Send content to TRMNL display
+ *   trmnl validate   - Validate payload without sending
+ *   trmnl config     - Manage CLI configuration
+ *   trmnl history    - View send history
+ */
+import cac from 'cac';
+import { registerConfigCommand } from './commands/config.ts';
+import { registerHistoryCommand } from './commands/history.ts';
+import { registerSendCommand } from './commands/send.ts';
+import { registerValidateCommand } from './commands/validate.ts';
+const cli = cac('trmnl');
+// Version from package.json
+cli.version('0.1.0');
+// Register commands
+registerSendCommand(cli);
+registerValidateCommand(cli);
+registerConfigCommand(cli);
+registerHistoryCommand(cli);
+// Help text
+cli.help();
+// Default action (no command)
+cli.command('').action(() => {
+  cli.outputHelp();
+});
+// Parse and run
+cli.parse();

package/src/lib/config.ts ADDED Viewed

@@ -0,0 +1,257 @@
+/**
+ * Config file management for ~/.trmnl/config.json
+ * Supports multiple plugins with a default
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import type { Config, Plugin, WebhookTier } from '../types.ts';
+import { DEFAULT_CONFIG } from '../types.ts';
+/** Config directory path */
+export const CONFIG_DIR = join(homedir(), '.trmnl');
+/** Config file path */
+export const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+/** Legacy TOML config path (for migration) */
+const LEGACY_CONFIG_PATH = join(CONFIG_DIR, 'config.toml');
+/** History file path */
+export const HISTORY_PATH = join(CONFIG_DIR, 'history.jsonl');
+/**
+ * Ensure ~/.trmnl directory exists
+ */
+export function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+/**
+ * Migrate legacy TOML config to JSON (one-time)
+ */
+function migrateLegacyConfig(): Config | null {
+  if (!existsSync(LEGACY_CONFIG_PATH)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(LEGACY_CONFIG_PATH, 'utf-8');
+    const config: Config = { plugins: {}, tier: 'free' };
+    // Parse legacy TOML (simple parser for our format)
+    let webhookUrl: string | undefined;
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      const urlMatch = trimmed.match(/^url\s*=\s*"([^"]+)"/);
+      if (urlMatch) webhookUrl = urlMatch[1];
+    }
+    if (webhookUrl) {
+      config.plugins['default'] = { url: webhookUrl };
+      config.defaultPlugin = 'default';
+    }
+    // Remove legacy file after migration
+    unlinkSync(LEGACY_CONFIG_PATH);
+    console.log('Migrated legacy config.toml to config.json');
+    return config;
+  } catch {
+    return null;
+  }
+}
+/**
+ * Load config from file
+ */
+export function loadConfig(): Config {
+  ensureConfigDir();
+  // Try to migrate legacy config first
+  const migrated = migrateLegacyConfig();
+  if (migrated) {
+    saveConfig(migrated);
+    return migrated;
+  }
+  if (!existsSync(CONFIG_PATH)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const content = readFileSync(CONFIG_PATH, 'utf-8');
+    const parsed = JSON.parse(content) as Partial<Config>;
+    return {
+      plugins: parsed.plugins || {},
+      defaultPlugin: parsed.defaultPlugin,
+      tier: parsed.tier || 'free',
+      history: parsed.history || DEFAULT_CONFIG.history,
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+/**
+ * Save config to file
+ */
+export function saveConfig(config: Config): void {
+  ensureConfigDir();
+  const content = JSON.stringify(config, null, 2);
+  writeFileSync(CONFIG_PATH, content, 'utf-8');
+}
+/**
+ * Get a plugin by name (or default if not specified)
+ */
+export function getPlugin(name?: string): { name: string; plugin: Plugin } | null {
+  const config = loadConfig();
+  // If name specified, use that
+  if (name) {
+    const plugin = config.plugins[name];
+    if (plugin) {
+      return { name, plugin };
+    }
+    return null;
+  }
+  // Use default plugin
+  const defaultName = config.defaultPlugin;
+  if (defaultName && config.plugins[defaultName]) {
+    return { name: defaultName, plugin: config.plugins[defaultName] };
+  }
+  // If only one plugin, use it
+  const pluginNames = Object.keys(config.plugins);
+  if (pluginNames.length === 1) {
+    const name = pluginNames[0];
+    return { name, plugin: config.plugins[name] };
+  }
+  return null;
+}
+/**
+ * Add or update a plugin
+ */
+export function setPlugin(name: string, url: string, description?: string): void {
+  const config = loadConfig();
+  config.plugins[name] = { url, description };
+  // If no default and this is the first plugin, make it default
+  if (!config.defaultPlugin || Object.keys(config.plugins).length === 1) {
+    config.defaultPlugin = name;
+  }
+  saveConfig(config);
+}
+/**
+ * Remove a plugin
+ */
+export function removePlugin(name: string): boolean {
+  const config = loadConfig();
+  if (!config.plugins[name]) {
+    return false;
+  }
+  delete config.plugins[name];
+  // If we removed the default, pick a new one
+  if (config.defaultPlugin === name) {
+    const remaining = Object.keys(config.plugins);
+    config.defaultPlugin = remaining.length > 0 ? remaining[0] : undefined;
+  }
+  saveConfig(config);
+  return true;
+}
+/**
+ * Set the default plugin
+ */
+export function setDefaultPlugin(name: string): boolean {
+  const config = loadConfig();
+  if (!config.plugins[name]) {
+    return false;
+  }
+  config.defaultPlugin = name;
+  saveConfig(config);
+  return true;
+}
+/**
+ * List all plugins
+ */
+export function listPlugins(): Array<{ name: string; plugin: Plugin; isDefault: boolean }> {
+  const config = loadConfig();
+  return Object.entries(config.plugins).map(([name, plugin]) => ({
+    name,
+    plugin,
+    isDefault: name === config.defaultPlugin,
+  }));
+}
+/**
+ * Get global tier setting
+ */
+export function getTier(): WebhookTier {
+  const config = loadConfig();
+  return config.tier || 'free';
+}
+/**
+ * Set global tier setting
+ */
+export function setTier(tier: WebhookTier): void {
+  const config = loadConfig();
+  config.tier = tier;
+  saveConfig(config);
+}
+/**
+ * Get webhook URL from environment, plugin name, or default
+ */
+export function getWebhookUrl(pluginName?: string): { url: string; name: string } | null {
+  // Environment variable takes highest precedence
+  const envUrl = process.env.TRMNL_WEBHOOK;
+  if (envUrl) {
+    return { url: envUrl, name: '$TRMNL_WEBHOOK' };
+  }
+  // Try to get plugin
+  const result = getPlugin(pluginName);
+  if (result) {
+    return {
+      url: result.plugin.url,
+      name: result.name,
+    };
+  }
+  return null;
+}
+/**
+ * Get history config
+ */
+export function getHistoryConfig(): { path: string; maxSizeMb: number } {
+  const config = loadConfig();
+  const historyPath = config.history?.path || DEFAULT_CONFIG.history!.path!;
+  const expandedPath = historyPath.startsWith('~')
+    ? historyPath.replace('~', homedir())
+    : historyPath;
+  return {
+    path: expandedPath,
+    maxSizeMb: config.history?.maxSizeMb || DEFAULT_CONFIG.history!.maxSizeMb!,
+  };
+}

package/src/lib/index.ts ADDED Viewed

@@ -0,0 +1,8 @@
+/**
+ * Library exports for programmatic use
+ */
+export * from './config.ts';
+export * from './logger.ts';
+export * from './validator.ts';
+export * from './webhook.ts';

package/src/lib/logger.ts ADDED Viewed

@@ -0,0 +1,141 @@
+/**
+ * JSONL history logger for tracking sent payloads
+ */
+import { appendFileSync, existsSync, readFileSync, statSync } from 'node:fs';
+import { ensureConfigDir, getHistoryConfig } from './config.ts';
+import type { HistoryEntry } from '../types.ts';
+/**
+ * Append a history entry to the JSONL file
+ */
+export function logEntry(entry: HistoryEntry): void {
+  ensureConfigDir();
+  const { path } = getHistoryConfig();
+  const line = JSON.stringify(entry) + '\n';
+  appendFileSync(path, line, 'utf-8');
+}
+/**
+ * Read all history entries
+ */
+export function readHistory(): HistoryEntry[] {
+  const { path } = getHistoryConfig();
+  if (!existsSync(path)) {
+    return [];
+  }
+  try {
+    const content = readFileSync(path, 'utf-8');
+    const lines = content.trim().split('\n').filter(Boolean);
+    return lines.map(line => JSON.parse(line) as HistoryEntry);
+  } catch {
+    return [];
+  }
+}
+/**
+ * Get history entries with filters
+ */
+export interface HistoryFilter {
+  last?: number;
+  today?: boolean;
+  failed?: boolean;
+  success?: boolean;
+  plugin?: string;
+  since?: Date;
+  until?: Date;
+}
+export function getHistory(filter: HistoryFilter = {}): HistoryEntry[] {
+  let entries = readHistory();
+  // Filter by plugin
+  if (filter.plugin) {
+    entries = entries.filter(e => e.plugin === filter.plugin);
+  }
+  // Filter by success/failed
+  if (filter.failed) {
+    entries = entries.filter(e => !e.success);
+  }
+  if (filter.success) {
+    entries = entries.filter(e => e.success);
+  }
+  // Filter by date
+  if (filter.today) {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    entries = entries.filter(e => new Date(e.timestamp) >= today);
+  }
+  if (filter.since) {
+    entries = entries.filter(e => new Date(e.timestamp) >= filter.since!);
+  }
+  if (filter.until) {
+    entries = entries.filter(e => new Date(e.timestamp) <= filter.until!);
+  }
+  // Sort by timestamp descending (most recent first)
+  entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  // Limit results
+  if (filter.last) {
+    entries = entries.slice(0, filter.last);
+  }
+  return entries;
+}
+/**
+ * Format a history entry for display
+ */
+export function formatEntry(entry: HistoryEntry, verbose = false): string {
+  const time = new Date(entry.timestamp).toLocaleString();
+  const status = entry.success ? '✓' : '✗';
+  const sizeKb = (entry.size_bytes / 1024).toFixed(2);
+  let line = `${status} ${time} | ${entry.plugin} | ${sizeKb} KB | ${entry.duration_ms}ms`;
+  if (!entry.success && entry.error) {
+    line += ` | ${entry.error}`;
+  }
+  if (verbose && entry.payload?.merge_variables?.content) {
+    const preview = entry.payload.merge_variables.content.substring(0, 80);
+    line += `\n   ${preview}${entry.payload.merge_variables.content.length > 80 ? '...' : ''}`;
+  }
+  return line;
+}
+/**
+ * Get history file stats
+ */
+export function getHistoryStats(): { entries: number; sizeBytes: number; sizeMb: number } | null {
+  const { path } = getHistoryConfig();
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const stats = statSync(path);
+    const entries = readHistory().length;
+    return {
+      entries,
+      sizeBytes: stats.size,
+      sizeMb: Math.round((stats.size / 1024 / 1024) * 100) / 100,
+    };
+  } catch {
+    return null;
+  }
+}
+/**
+ * Get history file path
+ */
+export function getHistoryPath(): string {
+  return getHistoryConfig().path;
+}