@darksol/terminal 0.10.0 → 0.11.0

package/README.md

@@ -15,7 +15,7 @@ A unified CLI for market intel, trading, AI-powered analysis, on-chain oracle, c
 [![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-gold.svg)](https://www.gnu.org/licenses/gpl-3.0)
 [![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-green.svg)](https://nodejs.org/)
 
-- Current release: **0.9.2**
+- Current release: **0.11.0**
 - Changelog: `CHANGELOG.md`
 
 ## Install
@@ -81,6 +81,27 @@ darksol serve
 
 # Start agent signer for OpenClaw
 darksol agent start main
+
+# Telegram bot — AI chat through Telegram
+darksol telegram setup
+darksol telegram start
+darksol telegram status
+darksol telegram send 123456789 "Hello from DARKSOL"
+
+# Background daemon — manage persistent services
+darksol daemon start
+darksol daemon status
+darksol daemon stop
+
+# Browser automation (requires: npm i playwright-core)
+darksol browser launch --headed
+darksol browser navigate https://app.uniswap.org
+darksol browser screenshot swap-page.png
+darksol browser click "#swap-button"
+darksol browser type "#amount-input" "1.0"
+darksol browser eval "document.title"
+darksol browser close
+darksol browser install
 ```
 
 ## `darksol serve` (Web Terminal UX)
@@ -147,11 +168,100 @@ ai <prompt>   # chat with trading assistant
 | `cards` | Crypto → prepaid Visa/MC cards | Service fees |
 | `builders` | ERC-8021 builder directory + leaderboard | Free |
 | `facilitator` | x402 payment verification & settlement | Free |
+| `telegram` | Telegram bot — AI chat via Telegram Bot API | Provider dependent |
+| `daemon` | Background service daemon (manages TG, browser, etc.) | Free |
+| `browser` | Playwright-powered browser automation | Free |
 | `serve` | Local interactive web terminal (xterm.js) | Free |
 | `config` | Terminal configuration | Free |
 
 ---
 
+## 📱 Telegram Bot
+
+Turn your terminal into a Telegram AI agent. Same brain (LLM + soul + memory), different mouth.
+
+```bash
+# Guided setup — walks you through BotFather
+darksol telegram setup
+
+# Start the bot (foreground, or managed by daemon)
+darksol telegram start
+
+# Check bot status
+darksol telegram status
+
+# Send a direct message
+darksol telegram send <chat_id> "Hello from DARKSOL"
+```
+
+**Setup walkthrough:**
+1. Open Telegram → search `@BotFather` → send `/newbot`
+2. Follow BotFather's prompts to name your bot
+3. Copy the bot token
+4. Run `darksol telegram setup` → paste token → auto-validates via `getMe`
+5. Token encrypted and stored in your key vault
+6. `darksol telegram start` → bot goes live
+
+**Features:**
+- Per-chat session memory (remembers conversation context)
+- Soul system prompt (your agent's personality carries over)
+- Built-in commands: `/start`, `/help`, `/status`
+- Typing indicators while LLM processes
+- Rate limiting (1 req/sec per chat)
+- 429 auto-retry for Telegram API limits
+- Daemon-aware: runs foreground solo, or as a managed service
+
+---
+
+## 🖥️ Background Daemon
+
+One process to rule them all. Manages persistent services (Telegram bot, browser, future channels).
+
+```bash
+darksol daemon start              # Detached background process
+darksol daemon status             # PID, uptime, active services
+darksol daemon stop               # Graceful shutdown
+darksol daemon restart            # Stop + start
+darksol daemon start --port 9999  # Custom health port
+```
+
+**Health endpoint:** `http://localhost:18792/health` — returns uptime, version, active services list.
+
+**Service registry:** Services (Telegram, browser, etc.) register with the daemon for managed lifecycle. Start once, everything runs.
+
+---
+
+## 🌐 Browser Automation
+
+Playwright-powered browser control — automate dApps, scrape data, take screenshots.
+
+```bash
+# Install browser binary (one-time)
+darksol browser install
+
+# Launch and control
+darksol browser launch --headed --type chromium
+darksol browser navigate https://app.uniswap.org
+darksol browser screenshot swap-page.png
+darksol browser click "#connect-wallet"
+darksol browser type "#search" "AERO"
+darksol browser eval "document.title"
+darksol browser status
+darksol browser close
+```
+
+**Requires:** `npm install playwright-core` (optional dependency — only needed if you use browser features).
+
+**Features:**
+- Chromium, Firefox, or WebKit
+- Headless (default) or headed mode
+- Named profiles with persistent cookies/sessions (`~/.darksol/browser/profiles/`)
+- IPC via named pipes — CLI commands talk to a running browser instance
+- Web shell integration (`browser` command in `darksol serve`)
+- Daemon-managed when running
+
+---
+
 ## 🔐 Secure Agent Signer
 
 **The killer feature.** A PK-isolated signing proxy for AI agents (OpenClaw, etc.).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darksol/terminal",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "DARKSOL Terminal — unified CLI for all DARKSOL services. Market intel, trading, oracle, casino, and more.",
   "type": "module",
   "bin": {
@@ -46,6 +46,9 @@
     "update-notifier": "^7.3.1",
     "ws": "^8.19.0"
   },
+  "optionalDependencies": {
+    "playwright-core": "^1.52.0"
+  },
   "engines": {
     "node": ">=18.0.0"
   }

package/src/browser/actions.js

@@ -0,0 +1,58 @@
+import { sendBrowserCommand } from '../services/browser.js';
+
+const DEFAULT_TIMEOUT = 30_000;
+
+export async function waitForPage(target, opts = {}) {
+  const expression = JSON.stringify(target);
+  return sendBrowserCommand('eval', {
+    expression: `
+      new Promise((resolve) => {
+        const target = ${expression};
+        const timeout = ${Number(opts.timeout || DEFAULT_TIMEOUT)};
+        const start = Date.now();
+        const check = () => {
+          const matches = typeof target === 'string'
+            ? window.location.href.includes(target)
+            : true;
+          if (matches) return resolve({ ok: true, url: window.location.href });
+          if (Date.now() - start > timeout) return resolve({ ok: false, url: window.location.href });
+          setTimeout(check, 250);
+        };
+        check();
+      })
+    `,
+  });
+}
+
+export async function fillForm(fields = [], opts = {}) {
+  for (const field of fields) {
+    await sendBrowserCommand('type', {
+      selector: field.selector,
+      text: field.value,
+      timeout: opts.timeout || DEFAULT_TIMEOUT,
+    });
+  }
+  return true;
+}
+
+export async function runLoginFlow(flow = {}) {
+  if (flow.url) {
+    await sendBrowserCommand('navigate', {
+      url: flow.url,
+      timeout: flow.timeout || DEFAULT_TIMEOUT,
+    });
+  }
+  if (Array.isArray(flow.fields) && flow.fields.length) {
+    await fillForm(flow.fields, flow);
+  }
+  if (flow.submitSelector) {
+    await sendBrowserCommand('click', {
+      selector: flow.submitSelector,
+      timeout: flow.timeout || DEFAULT_TIMEOUT,
+    });
+  }
+  if (flow.waitFor) {
+    await waitForPage(flow.waitFor, flow);
+  }
+  return sendBrowserCommand('status');
+}

package/src/cli.js

@@ -22,6 +22,17 @@ import { cardsCatalog, cardsOrder, cardsStatus } from './services/cards.js';
 import { facilitatorHealth, facilitatorVerify, facilitatorSettle } from './services/facilitator.js';
 import { buildersLeaderboard, buildersLookup, buildersFeed } from './services/builders.js';
 import { createScript, listScripts, runScript, showScript, editScript, deleteScript, cloneScript, listTemplates } from './scripts/engine.js';
+import {
+  launchBrowserCommand,
+  navigateBrowserCommand,
+  browserScreenshotCommand,
+  browserClickCommand,
+  browserTypeCommand,
+  browserEvalCommand,
+  browserCloseCommand,
+  showBrowserStatus,
+  installPlaywrightBrowsers,
+} from './services/browser.js';
 import { showTradingTips, showScriptTips, showNetworkReference, showQuickStart, showWalletSummary, showTokenInfo, showTxResult } from './utils/helpers.js';
 import { addKey, removeKey, listKeys } from './config/keys.js';
 import { parseIntent, startChat, adviseStrategy, analyzeToken, executeIntent } from './llm/intent.js';
@@ -31,6 +42,8 @@ import { runSetupWizard } from './setup/wizard.js';
 import { displaySoul, hasSoul, resetSoul, runSoulSetup } from './soul/index.js';
 import { clearMemories, exportMemories, getRecentMemories, searchMemories } from './memory/index.js';
 import { getAgentStatus, planAgentGoal, runAgentTask } from './agent/index.js';
+import { daemonStart, daemonStop, daemonStatus, daemonRestart } from './daemon/index.js';
+import { telegramSetup, telegramStartForeground, telegramStopCommand, telegramStatusCommand, telegramSendCommand } from './services/telegram.js';
 import { createRequire } from 'module';
 import { resolve } from 'path';
 import { getConfiguredModel, getProviderDefaultModel } from './llm/models.js';
@@ -608,6 +621,64 @@ export function cli(argv) {
     .option('--no-open', 'Don\'t auto-open browser')
     .action((opts) => startWebShell(opts));
 
+  const browser = program
+    .command('browser')
+    .description('Playwright-powered browser automation');
+
+  browser
+    .command('launch')
+    .description('Launch a browser instance and keep it running')
+    .option('--headed', 'Launch with a visible browser window')
+    .option('--type <browser>', 'Browser type', 'chromium')
+    .option('--profile <name>', 'Browser profile name', 'default')
+    .action((opts) => launchBrowserCommand(opts));
+
+  browser
+    .command('navigate <url>')
+    .description('Navigate the active page to a URL')
+    .action((url) => navigateBrowserCommand(url));
+
+  browser
+    .command('screenshot [filename]')
+    .description('Capture a screenshot of the active page')
+    .action((filename) => browserScreenshotCommand(filename));
+
+  browser
+    .command('click <selector>')
+    .description('Click an element on the active page')
+    .action((selector) => browserClickCommand(selector));
+
+  browser
+    .command('type <selector> <text>')
+    .description('Type text into an element on the active page')
+    .action((selector, text) => browserTypeCommand(selector, text));
+
+  browser
+    .command('eval <js>')
+    .description('Evaluate JavaScript in the active page')
+    .action((js) => browserEvalCommand(js));
+
+  browser
+    .command('close')
+    .description('Close the running browser service')
+    .action(() => browserCloseCommand());
+
+  browser
+    .command('status')
+    .description('Show current browser state')
+    .action(() => showBrowserStatus());
+
+  browser
+    .command('install')
+    .description('Install a Playwright browser binary after user confirmation')
+    .action(async () => {
+      try {
+        await installPlaywrightBrowsers();
+      } catch (err) {
+        error(err.message);
+      }
+    });
+
   // ═══════════════════════════════════════
   // PORTFOLIO SHORTCUT
   // ═══════════════════════════════════════
@@ -1031,6 +1102,68 @@ export function cli(argv) {
     .description('Uninstall a skill')
     .action((name) => uninstallSkill(name));
 
+  // ═══════════════════════════════════════
+  // DAEMON COMMANDS
+  // ═══════════════════════════════════════
+  const daemon = program
+    .command('daemon')
+    .description('Background daemon - manage persistent services');
+
+  daemon
+    .command('start')
+    .description('Start the background daemon')
+    .option('-p, --port <port>', 'Health server port', '18792')
+    .action((opts) => daemonStart(opts));
+
+  daemon
+    .command('stop')
+    .description('Stop the background daemon')
+    .action(() => daemonStop());
+
+  daemon
+    .command('status')
+    .description('Show daemon status and health')
+    .option('-p, --port <port>', 'Health server port', '18792')
+    .action((opts) => daemonStatus(opts));
+
+  daemon
+    .command('restart')
+    .description('Restart the daemon')
+    .option('-p, --port <port>', 'Health server port', '18792')
+    .action((opts) => daemonRestart(opts));
+
+  // ═══════════════════════════════════════
+  // TELEGRAM COMMANDS
+  // ═══════════════════════════════════════
+  const telegram = program
+    .command('telegram')
+    .description('Telegram bot - AI chat via Telegram');
+
+  telegram
+    .command('setup')
+    .description('Interactive Telegram bot setup with BotFather')
+    .action(() => telegramSetup());
+
+  telegram
+    .command('start')
+    .description('Start the Telegram bot (foreground)')
+    .action(() => telegramStartForeground());
+
+  telegram
+    .command('stop')
+    .description('Stop the Telegram bot')
+    .action(() => telegramStopCommand());
+
+  telegram
+    .command('status')
+    .description('Show bot info and connection state')
+    .action(() => telegramStatusCommand());
+
+  telegram
+    .command('send <chatId> <message...>')
+    .description('Send a direct message to a chat')
+    .action((chatId, message) => telegramSendCommand(chatId, message));
+
   // ═══════════════════════════════════════
   // TIPS & REFERENCE COMMANDS
   // ═══════════════════════════════════════
@@ -1602,6 +1735,9 @@ function showCommandList() {
     ['mail', 'AgentMail - email for your agent'],
     ['facilitator', 'x402 payment facilitator'],
     ['skills', 'Agent skill directory'],
+    ['browser', 'Playwright browser automation'],
+    ['daemon', 'Background service daemon'],
+    ['telegram', 'Telegram bot - AI chat'],
     ['serve', 'Launch web terminal in browser'],
     ['setup', 'Re-run setup wizard'],
     ['config', 'Terminal configuration'],

package/src/config/keys.js

@@ -178,6 +178,16 @@ export const SERVICES = {
     docsUrl: 'https://console.agentmail.to',
     validate: (key) => key.startsWith('am_'),
   },
+
+  // Messaging
+  telegram: {
+    name: 'Telegram Bot',
+    category: 'messaging',
+    description: 'Telegram bot token — AI chat via Telegram',
+    envVar: 'TELEGRAM_BOT_TOKEN',
+    docsUrl: 'https://core.telegram.org/bots#botfather',
+    validate: (key) => /^\d+:.+$/.test(key),
+  },
   paraswap: {
     name: 'ParaSwap',
     category: 'trading',
@@ -319,8 +329,8 @@ export function listKeys() {
 
   showSection('API KEY VAULT');
 
-  const categories = ['llm', 'data', 'rpc', 'trading', 'email'];
-  const catNames = { llm: '🧠 LLM PROVIDERS', data: '📊 DATA PROVIDERS', rpc: '🌐 RPC PROVIDERS', trading: '📈 TRADING', email: '📧 EMAIL' };
+  const categories = ['llm', 'data', 'rpc', 'trading', 'email', 'messaging'];
+  const catNames = { llm: '🧠 LLM PROVIDERS', data: '📊 DATA PROVIDERS', rpc: '🌐 RPC PROVIDERS', trading: '📈 TRADING', email: '📧 EMAIL', messaging: '💬 MESSAGING' };
 
   for (const cat of categories) {
     console.log('');

package/src/daemon/index.js

@@ -0,0 +1,225 @@
+import { spawn, execSync } from 'child_process';
+import { createServer } from 'http';
+import { appendFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import { writePid, readPid, removePid, getDaemonStatus, DARKSOL_DIR } from './pid.js';
+import { getAllServiceStatus, stopAllServices, listServices } from './manager.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn, info } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+import { createRequire } from 'module';
+import fetch from 'node-fetch';
+
+const require = createRequire(import.meta.url);
+const { version: PKG_VERSION } = require('../../package.json');
+
+const LOGS_DIR = join(DARKSOL_DIR, 'logs');
+const LOG_FILE = join(LOGS_DIR, 'daemon.log');
+const DEFAULT_PORT = 18792;
+
+function ensureLogsDir() {
+  if (!existsSync(LOGS_DIR)) mkdirSync(LOGS_DIR, { recursive: true });
+}
+
+function daemonLog(msg) {
+  ensureLogsDir();
+  const ts = new Date().toISOString();
+  appendFileSync(LOG_FILE, `[${ts}] ${msg}\n`, 'utf8');
+}
+
+/**
+ * Start the daemon as a detached background process.
+ * @param {object} [opts]
+ * @param {number} [opts.port]
+ */
+export async function daemonStart(opts = {}) {
+  const status = getDaemonStatus();
+  if (status.running) {
+    warn(`Daemon already running (PID ${status.pid})`);
+    return;
+  }
+
+  const port = parseInt(opts.port, 10) || DEFAULT_PORT;
+  const entryScript = fileURLToPath(new URL('./index.js', import.meta.url));
+
+  const child = spawn(process.execPath, [entryScript, '--daemon-run', String(port)], {
+    detached: true,
+    stdio: 'ignore',
+    env: { ...process.env, DARKSOL_DAEMON: '1' },
+  });
+
+  child.unref();
+
+  if (child.pid) {
+    writePid(child.pid);
+    success(`Daemon started (PID ${child.pid}, port ${port})`);
+    info(`Logs: ${LOG_FILE}`);
+    info(`Health: http://localhost:${port}/health`);
+  } else {
+    error('Failed to start daemon process');
+  }
+}
+
+/**
+ * Stop the running daemon.
+ */
+export async function daemonStop() {
+  const status = getDaemonStatus();
+  if (!status.running) {
+    warn('Daemon is not running');
+    return;
+  }
+
+  const spin = spinner('Stopping daemon...').start();
+
+  try {
+    if (process.platform === 'win32') {
+      execSync(`taskkill /PID ${status.pid} /F /T`, { stdio: 'ignore' });
+    } else {
+      process.kill(status.pid, 'SIGTERM');
+    }
+    removePid();
+    spin.succeed(`Daemon stopped (PID ${status.pid})`);
+  } catch (err) {
+    removePid();
+    spin.fail('Daemon stop had issues');
+    warn(err.message);
+  }
+}
+
+/**
+ * Show daemon status — process check + health endpoint query.
+ * @param {object} [opts]
+ * @param {number} [opts.port]
+ */
+export async function daemonStatus(opts = {}) {
+  const port = parseInt(opts.port, 10) || DEFAULT_PORT;
+  const status = getDaemonStatus();
+
+  showSection('DAEMON STATUS');
+
+  if (!status.running) {
+    kvDisplay([
+      ['Process', theme.dim('not running')],
+      ['PID File', theme.dim('none')],
+    ]);
+    console.log('');
+    info('Start with: darksol daemon start');
+    console.log('');
+    return;
+  }
+
+  // Process is alive — try health endpoint
+  let health = null;
+  try {
+    const res = await fetch(`http://localhost:${port}/health`, { timeout: 3000 });
+    if (res.ok) health = await res.json();
+  } catch {
+    // health endpoint unreachable
+  }
+
+  const pairs = [
+    ['Process', theme.success(`running (PID ${status.pid})`)],
+    ['Port', String(port)],
+  ];
+
+  if (health) {
+    pairs.push(['Uptime', `${Math.round(health.uptime)}s`]);
+    pairs.push(['Version', health.version || PKG_VERSION]);
+    pairs.push(['Services', health.services?.length ? health.services.join(', ') : theme.dim('none')]);
+  } else {
+    pairs.push(['Health', theme.warning('unreachable')]);
+  }
+
+  pairs.push(['Log', LOG_FILE]);
+  kvDisplay(pairs);
+  console.log('');
+}
+
+/**
+ * Restart the daemon (stop + start).
+ * @param {object} [opts]
+ */
+export async function daemonRestart(opts = {}) {
+  const status = getDaemonStatus();
+  if (status.running) {
+    await daemonStop();
+    // Brief pause to let the OS release the port
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  await daemonStart(opts);
+}
+
+// ─────────────────────────────────────
+// DAEMON PROCESS ENTRY (run by child)
+// ─────────────────────────────────────
+
+/**
+ * Run the actual daemon process (HTTP health server + service management).
+ * Called when the script is executed directly with --daemon-run.
+ * @param {number} port
+ */
+export async function runDaemonProcess(port) {
+  const startTime = Date.now();
+
+  daemonLog(`Daemon starting on port ${port} (PID ${process.pid})`);
+
+  const server = createServer((req, res) => {
+    if (req.url === '/health' && req.method === 'GET') {
+      const uptimeSec = (Date.now() - startTime) / 1000;
+      const services = getAllServiceStatus();
+      const body = JSON.stringify({
+        status: 'ok',
+        pid: process.pid,
+        uptime: uptimeSec,
+        version: PKG_VERSION,
+        services: services.map((s) => s.name),
+        serviceDetails: services,
+      });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(body);
+      return;
+    }
+
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'not found' }));
+  });
+
+  server.listen(port, '127.0.0.1', () => {
+    daemonLog(`Health server listening on http://127.0.0.1:${port}/health`);
+  });
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    daemonLog('Shutting down daemon...');
+    await stopAllServices();
+    server.close();
+    removePid();
+    daemonLog('Daemon stopped');
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+  process.on('uncaughtException', (err) => {
+    daemonLog(`Uncaught exception: ${err.message}`);
+  });
+  process.on('unhandledRejection', (err) => {
+    daemonLog(`Unhandled rejection: ${err}`);
+  });
+}
+
+// ─────────────────────────────────────
+// SELF-EXECUTION: when run directly as daemon child process
+// ─────────────────────────────────────
+
+const args = process.argv.slice(2);
+if (args[0] === '--daemon-run') {
+  const port = parseInt(args[1], 10) || DEFAULT_PORT;
+  writePid(process.pid);
+  runDaemonProcess(port);
+}
+
+export { DEFAULT_PORT, LOG_FILE };