morpheus-cli 0.1.0

package/README.md

@@ -0,0 +1,129 @@
+<div align="center">
+  <img src="./assets/logo.png" alt="Morpheus Logo" width="220" />
+</div>
+
+# Morpheus
+
+> **Morpheus is a local-first AI operator that bridges developers and machines.**
+
+Morpheus is a local AI agent for developers, running as a CLI daemon that connects to **LLMs**, **local tools**, and **MCPs**, enabling interaction via **Terminal, Telegram, and Discord**. Inspired by the character Morpheus from *The Matrix*, the project acts as an **intelligent orchestrator**, bridging the gap between the developer and complex systems.
+
+## Technical Overview
+
+Morpheus is built with **Node.js** and **TypeScript**, using **LangChain** as the orchestration engine. It runs as a background daemon process, managing connections to LLM providers (OpenAI, Anthropic, Ollama) and external channels (Telegram, Discord).
+
+### Core Components
+
+- **Runtime (`src/runtime/`)**: The heart of the application. Manages the agent lifecycle, provider instantiation, and command execution.
+- **CLI (`src/cli/`)**: Built with `commander`, handles user interaction, configuration, and daemon control (`start`, `stop`, `status`).
+- **Configuration (`src/config/`)**: Singleton-based configuration manager using `zod` for validation and `js-yaml` for persistence (`~/.morpheus/config.yaml`).
+- **Channels (`src/channels/`)**: Adapters for external communication. Currently supports Telegram (`telegraf`) with strict user whitelisting.
+
+## Prerequisites
+
+- **Node.js**: >= 18.x
+- **npm**: >= 9.x
+- **TypeScript**: >= 5.x
+
+## Getting Started (Development)
+
+This guide is for developers contributing to the Morpheus codebase.
+
+### 1. Clone & Install
+
+```bash
+git clone https://github.com/your-org/morpheus.git
+cd morpheus
+npm install
+```
+
+### 2. Build
+
+Compile TypeScript source to `dist/`.
+
+```bash
+npm run build
+```
+
+### 3. Run the CLI
+
+You can run the CLI directly from the source using `npm start`.
+
+```bash
+# Initialize configuration (creates ~/.morpheus)
+npm start -- init
+
+# Start the daemon
+npm start -- start
+
+# Check status
+npm start -- status
+```
+
+### 4. Configuration
+
+The configuration file is located at `~/.morpheus/config.yaml`. You can edit it manually or use the CLI.
+
+```yaml
+agent:
+  name: "Morpheus"
+  personality: "stoic, wise, and helpful"
+llm:
+  provider: "openai" # options: openai, anthropic, ollama
+  model: "gpt-4-turbo"
+  temperature: 0.7
+  api_key: "sk-..."
+channels:
+  telegram:
+    enabled: true
+    token: "YOUR_TELEGRAM_BOT_TOKEN"
+    allowedUsers: ["123456789"] # Your Telegram User ID
+```
+
+## Testing
+
+We use **Vitest** for testing.
+
+```bash
+# Run unit tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+```
+
+## Project Structure
+
+```text
+.
+├── assets/          # Static assets
+├── bin/             # CLI entry point (morpheus.js)
+├── specs/           # Technical specifications & documentation
+├── src/
+│   ├── channels/    # Communication adapters (Telegram, etc.)
+│   ├── cli/         # CLI commands and logic
+│   ├── config/      # Configuration management
+│   ├── runtime/     # Core agent logic, lifecycle, and providers
+│   ├── types/       # Shared TypeScript definitions
+│   └── index.ts
+└── package.json
+```
+
+## Roadmap
+
+- [ ] **MCP Support**: Full integration with Model Context Protocol.
+- [ ] **Discord Adapter**: Support for Discord interactions.
+- [ ] **Web Dashboard**: Local UI for management and logs.
+- [ ] **Plugin System**: Extend functionality via external modules.
+
+## Contributing
+
+1.  Fork the repository.
+2.  Create a feature branch (`git checkout -b feature/amazing-feature`).
+3.  Commit your changes (`git commit -m 'feat: Add amazing feature'`).
+4.  Push to the branch (`git push origin feature/amazing-feature`).
+5.  Open a Pull Request.
+
+## License
+
+MIT

package/bin/morpheus.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+// Suppress experimental warnings for JSON modules
+const originalEmit = process.emit;
+process.emit = function (name, data, ...args) {
+  if (
+    name === 'warning' &&
+    typeof data === 'object' &&
+    data.name === 'ExperimentalWarning' &&
+    data.message.includes('Importing JSON modules')
+  ) {
+    return false;
+  }
+  return originalEmit.apply(process, [name, data, ...args]);
+};
+
+// Use dynamic import to ensure the warning suppression is active before the module graph loads
+const { cli } = await import('../dist/cli/index.js');
+cli();

package/dist/channels/__tests__/telegram.test.js

@@ -0,0 +1,63 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { TelegramAdapter } from '../telegram.js';
+// Mock dependencies
+vi.mock('telegraf', () => {
+    return {
+        Telegraf: class {
+            telegram;
+            on;
+            launch;
+            stop;
+            constructor() {
+                this.telegram = {
+                    getMe: vi.fn().mockResolvedValue({ username: 'test_bot' }),
+                };
+                this.on = vi.fn();
+                this.launch = vi.fn().mockResolvedValue(undefined);
+                this.stop = vi.fn();
+            }
+        }
+    };
+});
+vi.mock('../../runtime/display.js', () => ({
+    DisplayManager: {
+        getInstance: () => ({
+            log: vi.fn(),
+        }),
+    },
+}));
+describe('TelegramAdapter', () => {
+    let adapter;
+    let mockAgent;
+    beforeEach(() => {
+        mockAgent = {
+            chat: vi.fn(),
+        };
+        adapter = new TelegramAdapter(mockAgent);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('Authorization', () => {
+        it('should be able to authorize trusted users', () => {
+            // Accessing private method for unit testing
+            const isAuthorized = adapter.isAuthorized.bind(adapter);
+            const allowed = ['123', '456'];
+            expect(isAuthorized('123', allowed)).toBe(true);
+            expect(isAuthorized('456', allowed)).toBe(true);
+            expect(isAuthorized('789', allowed)).toBe(false);
+        });
+        it('should handle numeric inputs converted to strings', () => {
+            const isAuthorized = adapter.isAuthorized.bind(adapter);
+            const allowed = ['123'];
+            // Telegram ID comes as string from our logic, but let's verify string comparison
+            expect(isAuthorized('123', allowed)).toBe(true);
+            expect(isAuthorized('1234', allowed)).toBe(false);
+        });
+    });
+    describe('Connection', () => {
+        it('should connect successfully with token', async () => {
+            await expect(adapter.connect('fake_token', ['123'])).resolves.not.toThrow();
+        });
+    });
+});

package/dist/channels/telegram.js

@@ -0,0 +1,89 @@
+import { Telegraf } from 'telegraf';
+import chalk from 'chalk';
+import { DisplayManager } from '../runtime/display.js';
+export class TelegramAdapter {
+    bot = null;
+    isConnected = false;
+    display = DisplayManager.getInstance();
+    agent;
+    constructor(agent) {
+        this.agent = agent;
+    }
+    async connect(token, allowedUsers) {
+        if (this.isConnected) {
+            this.display.log('Telegram adapter already connected.', { source: 'Telegram', level: 'warning' });
+            return;
+        }
+        try {
+            this.display.log('Connecting to Telegram...', { source: 'Telegram' });
+            this.bot = new Telegraf(token);
+            // Verify token/connection
+            const me = await this.bot.telegram.getMe();
+            this.display.log(`✓ Telegram Connected: @${me.username}`, { source: 'Telegram', level: 'success' });
+            this.display.log(`Allowed Users: ${allowedUsers.join(', ')}`, { source: 'Telegram', level: 'info' });
+            // Listen for messages
+            this.bot.on('text', async (ctx) => {
+                const user = ctx.from.username || ctx.from.first_name;
+                const userId = ctx.from.id.toString();
+                const text = ctx.message.text;
+                // AUTH GUARD
+                if (!this.isAuthorized(userId, allowedUsers)) {
+                    this.display.log(`Unauthorized access attempt by @${user} (ID: ${userId})`, { source: 'Telegram', level: 'warning' });
+                    return; // Silent fail for security
+                }
+                this.display.log(`@${user}: ${text}`, { source: 'Telegram' });
+                try {
+                    // Send "typing" status
+                    await ctx.sendChatAction('typing');
+                    // Process with Agent
+                    const response = await this.agent.chat(text);
+                    if (response) {
+                        await ctx.reply(response);
+                        this.display.log(`Responded to @${user}`, { source: 'Telegram' });
+                    }
+                }
+                catch (error) {
+                    this.display.log(`Error processing message for @${user}: ${error.message}`, { source: 'Telegram', level: 'error' });
+                    try {
+                        await ctx.reply("Sorry, I encountered an error while processing your request.");
+                    }
+                    catch (e) {
+                        // Ignore reply error
+                    }
+                }
+            });
+            this.bot.launch().catch((err) => {
+                if (this.isConnected) {
+                    this.display.log(`Telegram bot error: ${err}`, { source: 'Telegram', level: 'error' });
+                }
+            });
+            this.isConnected = true;
+            process.once('SIGINT', () => this.disconnect());
+            process.once('SIGTERM', () => this.disconnect());
+        }
+        catch (error) {
+            this.display.log(`Failed to connect to Telegram: ${error.message}`, { source: 'Telegram', level: 'error' });
+            this.isConnected = false;
+            this.bot = null;
+            throw error;
+        }
+    }
+    isAuthorized(userId, allowedUsers) {
+        return allowedUsers.includes(userId);
+    }
+    async disconnect() {
+        if (!this.isConnected || !this.bot) {
+            return;
+        }
+        this.display.log('Disconnecting Telegram...', { source: 'Telegram', level: 'warning' });
+        try {
+            this.bot.stop();
+        }
+        catch (e) {
+            // Ignore stop errors
+        }
+        this.isConnected = false;
+        this.bot = null;
+        this.display.log(chalk.gray('Telegram disconnected.'), { source: 'Telegram' });
+    }
+}

package/dist/cli/commands/config.js

@@ -0,0 +1,81 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import open from 'open';
+import fs from 'fs-extra';
+import { PATHS } from '../../config/paths.js';
+import { scaffold } from '../../runtime/scaffold.js';
+import { ConfigManager } from '../../config/manager.js';
+function parseValue(value) {
+    if (value.toLowerCase() === 'true')
+        return true;
+    if (value.toLowerCase() === 'false')
+        return false;
+    if (!Number.isNaN(Number(value)) && value.trim() !== '') {
+        return Number(value);
+    }
+    return value;
+}
+export const configCommand = new Command('config')
+    .description('View or edit configuration')
+    .option('-e, --edit', 'Open config file in default editor')
+    .action(async (options) => {
+    try {
+        await scaffold(); // Ensure config exits
+        if (options.edit) {
+            console.log(chalk.cyan(`Opening config file: ${PATHS.config}`));
+            await open(PATHS.config);
+        }
+        else {
+            console.log(chalk.bold('Configuration File:'), chalk.cyan(PATHS.config));
+            console.log(chalk.gray('---'));
+            if (await fs.pathExists(PATHS.config)) {
+                const content = await fs.readFile(PATHS.config, 'utf8');
+                console.log(content);
+            }
+            else {
+                console.log(chalk.yellow('Config file not found (scaffold should have created it).'));
+            }
+            console.log(chalk.gray('---'));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to handle config command:'), error.message);
+        process.exit(1);
+    }
+});
+configCommand.command('set')
+    .description('Set a configuration value')
+    .argument('<key>', 'Configuration key (e.g. channels.telegram.enabled)')
+    .argument('<value>', 'Value to set')
+    .action(async (key, value) => {
+    try {
+        await scaffold(); // Ensure config loads 
+        const manager = ConfigManager.getInstance();
+        await manager.load();
+        const parsedValue = parseValue(value);
+        try {
+            await manager.set(key, parsedValue);
+            console.log(chalk.green(`✓ Set ${key} = ${parsedValue}`));
+        }
+        catch (e) {
+            // Fallback: If Zod fails, maybe it was a string that looked like a number?
+            if (typeof parsedValue === 'number') {
+                try {
+                    await manager.set(key, value); // Try original string
+                    console.log(chalk.green(`✓ Set ${key} = "${value}" (treated as string)`));
+                    return;
+                }
+                catch (ignored) { }
+            }
+            throw e;
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to set config:'), error.message || error);
+        if (error.issues) {
+            // Zod error
+            console.error(chalk.red('Validation issues:'), JSON.stringify(error.issues, null, 2));
+        }
+        process.exit(1);
+    }
+});

package/dist/cli/commands/doctor.js

@@ -0,0 +1,69 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { PATHS } from '../../config/paths.js';
+import { ConfigManager } from '../../config/manager.js';
+export const doctorCommand = new Command('doctor')
+    .description('Diagnose environment and configuration issues')
+    .action(async () => {
+    console.log(chalk.bold('Morpheus Doctor'));
+    console.log(chalk.gray('================'));
+    let allPassed = true;
+    // 1. Check Node.js Version
+    const nodeVersion = process.version;
+    const majorVersion = parseInt(nodeVersion.replace('v', '').split('.')[0], 10);
+    if (majorVersion >= 18) {
+        console.log(chalk.green('✓') + ` Node.js Version: ${nodeVersion} (Satisfied)`);
+    }
+    else {
+        console.log(chalk.red('✗') + ` Node.js Version: ${nodeVersion} (Required: >=18)`);
+        allPassed = false;
+    }
+    // 2. Check Configuration
+    try {
+        if (await fs.pathExists(PATHS.config)) {
+            await ConfigManager.getInstance().load();
+            console.log(chalk.green('✓') + ' Configuration: Valid');
+        }
+        else {
+            console.log(chalk.yellow('!') + ' Configuration: Missing (will be created on start)');
+        }
+    }
+    catch (error) {
+        console.log(chalk.red('✗') + ` Configuration: Invalid (${error.message})`);
+        allPassed = false;
+    }
+    // 3. Check Permissions
+    try {
+        await fs.ensureDir(PATHS.root);
+        const testFile = path.join(PATHS.root, '.perm-test');
+        await fs.writeFile(testFile, 'test');
+        await fs.remove(testFile);
+        console.log(chalk.green('✓') + ` Permissions: Write access to ${PATHS.root}`);
+    }
+    catch (error) {
+        console.log(chalk.red('✗') + ` Permissions: Cannot write to ${PATHS.root}`);
+        allPassed = false;
+    }
+    // 4. Check Logs Permissions
+    try {
+        await fs.ensureDir(PATHS.logs);
+        const testLogFile = path.join(PATHS.logs, '.perm-test');
+        await fs.writeFile(testLogFile, 'test');
+        await fs.remove(testLogFile);
+        console.log(chalk.green('✓') + ` Logs: Write access to ${PATHS.logs}`);
+    }
+    catch (error) {
+        console.log(chalk.red('✗') + ` Logs: Cannot write to ${PATHS.logs}`);
+        allPassed = false;
+    }
+    console.log(chalk.gray('================'));
+    if (allPassed) {
+        console.log(chalk.green('Diagnostics Passed. You are ready to run Morpheus!'));
+    }
+    else {
+        console.log(chalk.red('Issues detected. Please fix them before running Morpheus.'));
+        process.exit(1);
+    }
+});

package/dist/cli/commands/init.js

@@ -0,0 +1,108 @@
+import { Command } from 'commander';
+import { input, select, password, confirm, checkbox } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { ConfigManager } from '../../config/manager.js';
+import { renderBanner } from '../utils/render.js';
+import { DisplayManager } from '../../runtime/display.js';
+import { scaffold } from '../../runtime/scaffold.js';
+export const initCommand = new Command('init')
+    .description('Initialize Morpheus configuration')
+    .action(async () => {
+    const display = DisplayManager.getInstance();
+    renderBanner();
+    // Ensure directory exists
+    await scaffold();
+    display.log(chalk.blue('Let\'s set up your Morpheus agent!'));
+    try {
+        const name = await input({
+            message: 'Name your agent:',
+            default: 'morpheus',
+        });
+        const personality = await input({
+            message: 'Describe its personality:',
+            default: 'helpful and concise',
+        });
+        const provider = await select({
+            message: 'Select LLM Provider:',
+            choices: [
+                { name: 'OpenAI', value: 'openai' },
+                { name: 'Anthropic', value: 'anthropic' },
+                { name: 'Ollama', value: 'ollama' },
+                { name: 'Google Gemini', value: 'gemini' },
+            ],
+        });
+        let defaultModel = 'gpt-3.5-turbo';
+        switch (provider) {
+            case 'openai':
+                defaultModel = 'gpt-4o';
+                break;
+            case 'anthropic':
+                defaultModel = 'claude-3-5-sonnet-20240620';
+                break;
+            case 'ollama':
+                defaultModel = 'llama3';
+                break;
+            case 'gemini':
+                defaultModel = 'gemini-pro';
+                break;
+        }
+        const model = await input({
+            message: 'Enter Model Name:',
+            default: defaultModel,
+        });
+        let apiKey;
+        if (provider !== 'ollama') {
+            apiKey = await password({
+                message: 'Enter API Key (leave empty if using env vars):',
+            });
+        }
+        const configManager = ConfigManager.getInstance();
+        // Update config
+        await configManager.set('agent.name', name);
+        await configManager.set('agent.personality', personality);
+        await configManager.set('llm.provider', provider);
+        await configManager.set('llm.model', model);
+        if (apiKey) {
+            await configManager.set('llm.api_key', apiKey);
+        }
+        // External Channels Configuration
+        const configureChannels = await confirm({
+            message: 'Do you want to configure external channels?',
+            default: false,
+        });
+        if (configureChannels) {
+            const channels = await checkbox({
+                message: 'Select channels to enable:',
+                choices: [
+                    { name: 'Telegram', value: 'telegram' },
+                ],
+            });
+            if (channels.includes('telegram')) {
+                display.log(chalk.yellow('\n--- Telegram Configuration ---'));
+                display.log(chalk.gray('1. Create a bot via @BotFather to get your token.'));
+                display.log(chalk.gray('2. Get your User ID via @userinfobot.\n'));
+                const token = await password({
+                    message: 'Enter Telegram Bot Token:',
+                    validate: (value) => value.length > 0 || 'Token is required.'
+                });
+                const allowedUsersInput = await input({
+                    message: 'Enter Allowed User IDs (comma separated):',
+                    validate: (value) => value.length > 0 || 'At least one user ID is required for security.'
+                });
+                const allowedUsers = allowedUsersInput.split(',').map(id => id.trim()).filter(id => id.length > 0);
+                await configManager.set('channels.telegram.enabled', true);
+                await configManager.set('channels.telegram.token', token);
+                await configManager.set('channels.telegram.allowedUsers', allowedUsers);
+            }
+        }
+        display.log(chalk.green('\nConfiguration saved successfully!'));
+        display.log(chalk.cyan(`Run 'morpheus start' to launch ${name}.`));
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('force closed')) {
+            display.log(chalk.yellow('\nSetup cancelled.'));
+            return;
+        }
+        display.log(chalk.red('\nFailed to save configuration: ' + error.message));
+    }
+});