@tenex-chat/backend 0.9.1

package/src/commands/setup/global-system-prompt.ts

@@ -0,0 +1,223 @@
+import * as fileSystem from "@/lib/fs";
+import { config as configService } from "@/services/ConfigService";
+import { logger } from "@/utils/logger";
+import { Command } from "commander";
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+/**
+ * Get the user's preferred editor
+ * Checks $VISUAL, $EDITOR, then falls back to common defaults
+ */
+function getEditor(): string {
+    // Check standard environment variables
+    if (process.env.VISUAL) {
+        return process.env.VISUAL;
+    }
+    if (process.env.EDITOR) {
+        return process.env.EDITOR;
+    }
+
+    // Platform-specific defaults
+    if (process.platform === "win32") {
+        return "notepad";
+    }
+
+    // Unix-like systems - try common editors
+    return "nano"; // Most user-friendly default
+}
+
+/**
+ * Open a file in the user's preferred editor and wait for them to close it
+ */
+async function openInEditor(filePath: string): Promise<void> {
+    const editor = getEditor();
+
+    return new Promise((resolve, reject) => {
+        // Use shell to properly handle $EDITOR values with quoted paths or complex arguments
+        // e.g., EDITOR="code --wait" or EDITOR='"/path/with spaces/code" --wait'
+        const fullCommand = `${editor} "${filePath}"`;
+
+        logger.debug(`Opening editor with command: ${fullCommand}`);
+
+        const child = spawn(fullCommand, [], {
+            stdio: "inherit",
+            shell: true,
+        });
+
+        child.on("error", (error) => {
+            reject(new Error(`Failed to open editor '${editor}': ${error.message}`));
+        });
+
+        child.on("close", (code) => {
+            if (code === 0 || code === null) {
+                resolve();
+            } else {
+                reject(new Error(`Editor exited with code ${code}`));
+            }
+        });
+    });
+}
+
+/**
+ * Command for configuring global system prompt
+ *
+ * Opens the user's preferred editor to edit a system prompt fragment that
+ * will be added to ALL projects' system prompts.
+ */
+export const globalSystemPromptCommand = new Command("global-system-prompt")
+    .description("Configure a global system prompt that is added to all projects")
+    .option("--disable", "Disable the global system prompt without deleting it")
+    .option("--enable", "Enable the global system prompt")
+    .option("--show", "Show the current global system prompt")
+    .action(async (options) => {
+        try {
+            const globalPath = configService.getGlobalPath();
+
+            // Ensure global config directory exists
+            await fileSystem.ensureDirectory(globalPath);
+
+            // Load existing configuration
+            const existingConfig = await configService.loadTenexConfig(globalPath);
+
+            // Handle --show flag
+            if (options.show) {
+                const content = existingConfig.globalSystemPrompt?.content;
+                const enabled = existingConfig.globalSystemPrompt?.enabled !== false;
+
+                if (!content || content.trim().length === 0) {
+                    logger.info("No global system prompt configured.");
+                } else {
+                    logger.info(`Global System Prompt (${enabled ? "enabled" : "disabled"}):`);
+                    logger.info("─".repeat(50));
+                    console.log(content);
+                    logger.info("─".repeat(50));
+                }
+                return;
+            }
+
+            // Handle --disable flag
+            if (options.disable) {
+                const newConfig = {
+                    ...existingConfig,
+                    globalSystemPrompt: {
+                        ...existingConfig.globalSystemPrompt,
+                        enabled: false,
+                    },
+                };
+                await configService.saveGlobalConfig(newConfig);
+                logger.info("Global system prompt disabled.");
+                return;
+            }
+
+            // Handle --enable flag
+            if (options.enable) {
+                const newConfig = {
+                    ...existingConfig,
+                    globalSystemPrompt: {
+                        ...existingConfig.globalSystemPrompt,
+                        enabled: true,
+                    },
+                };
+                await configService.saveGlobalConfig(newConfig);
+                logger.info("Global system prompt enabled.");
+                return;
+            }
+
+            // Default action: open editor
+            // Create a temporary file with existing content
+            const tempDir = os.tmpdir();
+            const tempFile = path.join(tempDir, `tenex-global-prompt-${Date.now()}.md`);
+
+            // Delimiter that separates template instructions from user content
+            const CONTENT_DELIMITER = "---- YOUR PROMPT BELOW THIS LINE ----";
+
+            // Get existing content or provide a template
+            const existingContent = existingConfig.globalSystemPrompt?.content || "";
+            const templateHeader = `# Global System Prompt Configuration
+#
+# This content will be added to ALL agents' system prompts across ALL projects.
+#
+# Examples of what you might put here:
+# - Personal preferences (e.g., "Always use TypeScript strict mode")
+# - Coding standards (e.g., "Follow clean code principles")
+# - Communication preferences (e.g., "Be concise in responses")
+#
+# IMPORTANT: Write your prompt BELOW the delimiter line.
+# Everything above the delimiter will be discarded.
+# Everything below (including markdown # headings) will be preserved.
+#
+# Save and close this file when done.
+
+${CONTENT_DELIMITER}
+`;
+            const templateContent = templateHeader + existingContent;
+
+            await fs.writeFile(tempFile, templateContent, "utf-8");
+
+            logger.info(
+                "Opening editor to configure global system prompt...\n" +
+                    `(Using editor: ${getEditor()})\n`
+            );
+
+            // Open editor and wait for it to close - use try/finally for cleanup
+            let editedContent: string;
+            try {
+                await openInEditor(tempFile);
+                editedContent = await fs.readFile(tempFile, "utf-8");
+            } finally {
+                // Always clean up temp file, even on error or interrupt
+                try {
+                    await fs.unlink(tempFile);
+                } catch {
+                    // Ignore cleanup errors
+                }
+            }
+
+            // Extract content after the delimiter, preserving all content including # headings
+            const delimiterIndex = editedContent.indexOf(CONTENT_DELIMITER);
+            let cleanedContent: string;
+            if (delimiterIndex !== -1) {
+                // Take everything after the delimiter line
+                const afterDelimiter = editedContent.substring(
+                    delimiterIndex + CONTENT_DELIMITER.length
+                );
+                cleanedContent = afterDelimiter.trim();
+            } else {
+                // No delimiter found - use entire content (user may have deleted template)
+                cleanedContent = editedContent.trim();
+            }
+
+            // Save the configuration
+            const newConfig = {
+                ...existingConfig,
+                globalSystemPrompt: {
+                    enabled: true,
+                    content: cleanedContent,
+                },
+            };
+
+            await configService.saveGlobalConfig(newConfig);
+
+            if (cleanedContent.length === 0) {
+                logger.info("Global system prompt cleared (no content).");
+            } else {
+                logger.info(
+                    "Global system prompt saved successfully!\n" +
+                        `Content length: ${cleanedContent.length} characters\n\n` +
+                        "This prompt will be added to all agents' system prompts."
+                );
+            }
+        } catch (error: unknown) {
+            // Handle SIGINT (Ctrl+C) gracefully
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage?.includes("SIGINT") || errorMessage?.includes("force closed")) {
+                return;
+            }
+
+            logger.error(`Failed to configure global system prompt: ${error}`);
+            process.exitCode = 1;
+        }
+    });

package/src/commands/setup/image.ts

@@ -0,0 +1,179 @@
+import * as fileSystem from "@/lib/fs";
+import {
+    ImageGenerationService,
+    OPENROUTER_IMAGE_MODELS,
+    ASPECT_RATIOS,
+    IMAGE_SIZES,
+    type ImageConfig,
+} from "@/services/image/ImageGenerationService";
+import { config as configService } from "@/services/ConfigService";
+import { logger } from "@/utils/logger";
+import { Command } from "commander";
+import inquirer from "inquirer";
+
+/**
+ * Command for configuring image generation with OpenRouter
+ */
+export const imageCommand = new Command("image")
+    .description(
+        "Configure image generation model (global by default, --project for current project)"
+    )
+    .option("--project", "Use project-specific configuration instead of global")
+    .action(async (options) => {
+        try {
+            const scope: "global" | "project" = options.project ? "project" : "global";
+            const projectPath = process.cwd();
+            const baseDir =
+                scope === "project"
+                    ? configService.getProjectPath(projectPath)
+                    : configService.getGlobalPath();
+
+            if (scope === "project") {
+                // Check if we're in a TENEX project
+                if (!(await fileSystem.directoryExists(baseDir))) {
+                    logger.error(
+                        "No .tenex directory found. Make sure you're in a TENEX project directory."
+                    );
+                    process.exitCode = 1;
+                    return;
+                }
+            } else {
+                // Ensure global config directory exists
+                await fileSystem.ensureDirectory(baseDir);
+            }
+
+            // Load existing configuration
+            const existing = await ImageGenerationService.loadConfiguration({
+                scope,
+                projectPath: scope === "project" ? projectPath : undefined,
+            });
+
+            // Check if OpenRouter is configured
+            const providersConfig = await configService.loadTenexProviders(configService.getGlobalPath());
+            if (!providersConfig.providers.openrouter?.apiKey) {
+                logger.error(
+                    "OpenRouter is not configured. Run `tenex setup providers` and add your OpenRouter API key first."
+                );
+                logger.info(
+                    "\nImage generation requires OpenRouter. Get an API key at: https://openrouter.ai/keys"
+                );
+                process.exitCode = 1;
+                return;
+            }
+
+            logger.info("✓ OpenRouter API key found\n");
+
+            // Build model choices
+            const modelChoices = OPENROUTER_IMAGE_MODELS.map((m) => ({
+                name: `${m.name} - ${m.description}`,
+                value: m.value,
+            }));
+
+            // Add custom model option
+            modelChoices.push({
+                name: "Custom model (enter OpenRouter model ID)",
+                value: "custom",
+            });
+
+            // Prompt for model selection
+            const { model: selectedModel } = await inquirer.prompt([
+                {
+                    type: "select",
+                    name: "model",
+                    message: "Select default image generation model:",
+                    choices: modelChoices,
+                    default: existing?.model || OPENROUTER_IMAGE_MODELS[0]?.value,
+                },
+            ]);
+
+            let model = selectedModel;
+            if (selectedModel === "custom") {
+                const customAnswer = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "customModel",
+                        message: "Enter OpenRouter model ID (e.g., black-forest-labs/flux.2-pro):",
+                        validate: (input: string) =>
+                            input.trim().length > 0 || "Model ID cannot be empty",
+                    },
+                ]);
+                model = customAnswer.customModel;
+            }
+
+            // Prompt for default aspect ratio
+            const aspectRatioChoices = ASPECT_RATIOS.map((ratio) => {
+                let description = "";
+                if (ratio === "1:1") description = " (square)";
+                else if (ratio === "16:9") description = " (widescreen landscape)";
+                else if (ratio === "9:16") description = " (portrait/mobile)";
+                else if (ratio === "4:3") description = " (classic)";
+                else if (ratio === "3:4") description = " (portrait classic)";
+                else if (ratio === "3:2") description = " (photo landscape)";
+                else if (ratio === "2:3") description = " (photo portrait)";
+                return { name: `${ratio}${description}`, value: ratio };
+            });
+
+            const { aspectRatio } = await inquirer.prompt([
+                {
+                    type: "select",
+                    name: "aspectRatio",
+                    message: "Select default aspect ratio:",
+                    choices: aspectRatioChoices,
+                    default: existing?.defaultAspectRatio || "1:1",
+                },
+            ]);
+
+            // Prompt for default image size
+            const imageSizeChoices = IMAGE_SIZES.map((size) => {
+                let description = "";
+                if (size === "1K") description = " (fastest, lowest cost)";
+                else if (size === "2K") description = " (balanced)";
+                else if (size === "4K") description = " (highest quality, most expensive)";
+                return { name: `${size}${description}`, value: size };
+            });
+
+            const { imageSize } = await inquirer.prompt([
+                {
+                    type: "select",
+                    name: "imageSize",
+                    message: "Select default image size:",
+                    choices: imageSizeChoices,
+                    default: existing?.defaultImageSize || "2K",
+                },
+            ]);
+
+            // Save configuration
+            const imageConfig: ImageConfig = {
+                provider: "openrouter",
+                model,
+                defaultAspectRatio: aspectRatio,
+                defaultImageSize: imageSize,
+            };
+
+            await ImageGenerationService.saveConfiguration(imageConfig, scope, {
+                projectPath: scope === "project" ? projectPath : undefined,
+            });
+
+            // Get model display name
+            const modelInfo = OPENROUTER_IMAGE_MODELS.find((m) => m.value === model);
+            const modelDisplayName = modelInfo ? modelInfo.name : model;
+
+            logger.info(
+                `\n✅ Image generation configured for ${scope}\n` +
+                    `   Provider: OpenRouter\n` +
+                    `   Model: ${modelDisplayName} (${model})\n` +
+                    `   Default aspect ratio: ${aspectRatio}\n` +
+                    `   Default image size: ${imageSize}\n` +
+                    "\nAgents can now use the generate_image tool to create images."
+            );
+        } catch (error: unknown) {
+            // Handle SIGINT (Ctrl+C) gracefully
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage?.includes("SIGINT") || errorMessage?.includes("force closed")) {
+                return;
+            }
+
+            logger.error(`Failed to configure image generation: ${error}`);
+            process.exitCode = 1;
+        }
+    });

package/src/commands/setup/index.ts

@@ -0,0 +1,16 @@
+import { embedCommand } from "@/commands/setup/embed";
+import { globalSystemPromptCommand } from "@/commands/setup/global-system-prompt";
+import { imageCommand } from "@/commands/setup/image";
+import { llmCommand } from "@/commands/setup/llm";
+import { onboardingCommand } from "@/commands/setup/onboarding";
+import { providersCommand } from "@/commands/setup/providers";
+import { Command } from "commander";
+
+export const setupCommand = new Command("setup")
+    .description("Setup and configuration commands")
+    .addCommand(onboardingCommand, { isDefault: true })
+    .addCommand(providersCommand)
+    .addCommand(llmCommand)
+    .addCommand(embedCommand)
+    .addCommand(imageCommand)
+    .addCommand(globalSystemPromptCommand);

package/src/commands/setup/interactive.ts

@@ -0,0 +1,95 @@
+import { LLMConfigEditor } from "@/llm/LLMConfigEditor";
+import { config } from "@/services/ConfigService";
+import type { TenexConfig } from "@/services/config/types";
+import { logger } from "@/utils/logger";
+import chalk from "chalk";
+import inquirer from "inquirer";
+
+export async function runInteractiveSetup(): Promise<TenexConfig> {
+    logger.info(chalk.cyan("\n🚀 Welcome to TENEX Daemon Setup\n"));
+    logger.info("Let's configure your daemon to get started.\n");
+
+    // Load current configuration to check what's missing
+    const { config: currentConfig, llms: currentLLMs } = await config.loadConfig();
+    const needsPubkeys =
+        !currentConfig.whitelistedPubkeys || currentConfig.whitelistedPubkeys.length === 0;
+    const needsLLMs =
+        !currentLLMs.configurations || Object.keys(currentLLMs.configurations).length === 0;
+
+    let pubkeys = currentConfig.whitelistedPubkeys || [];
+
+    // Step 1: Get whitelisted pubkeys if needed
+    if (needsPubkeys) {
+        pubkeys = await promptForPubkeys();
+    }
+
+    const tenexConfig: TenexConfig = {
+        ...currentConfig,
+        whitelistedPubkeys: pubkeys,
+    };
+
+    // Step 2: Save basic configuration (preserving existing settings)
+    await config.saveGlobalConfig(tenexConfig);
+
+    // Step 3: Set up LLM configurations if needed
+    if (needsLLMs) {
+        logger.info(chalk.yellow("\nStep 2: LLM Configuration"));
+        logger.info("You need at least one LLM configuration to run projects.\n");
+
+        const llmEditor = new LLMConfigEditor();
+        await llmEditor.runOnboardingFlow();
+    }
+
+    logger.info(chalk.green("\n✅ Setup complete!"));
+    logger.info(chalk.green(`Configuration saved to: ${config.getGlobalPath()}/`));
+    logger.info(
+        chalk.gray("\nYou can now run 'tenex daemon' to start the daemon with your configuration.")
+    );
+
+    return tenexConfig;
+}
+
+async function promptForPubkeys(): Promise<string[]> {
+    logger.info(chalk.yellow("Step 1: Whitelist Configuration"));
+    logger.info("Enter the Nostr pubkeys (hex format) that are allowed to control this daemon.");
+    logger.info("You can add multiple pubkeys, one at a time.\n");
+
+    const pubkeys: string[] = [];
+    let addMore = true;
+
+    while (addMore) {
+        const { pubkey } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "pubkey",
+                message: "Enter a pubkey (hex format):",
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return "Pubkey cannot be empty";
+                    }
+                    if (!/^[a-f0-9]{64}$/i.test(input.trim())) {
+                        return "Invalid pubkey format. Must be 64 hex characters";
+                    }
+                    return true;
+                },
+            },
+        ]);
+
+        pubkeys.push(pubkey.trim().toLowerCase());
+
+        if (pubkeys.length > 0) {
+            const { continueAdding } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "continueAdding",
+                    message: "Add another pubkey?",
+                    default: false,
+                },
+            ]);
+            addMore = continueAdding;
+        }
+    }
+
+    logger.info(chalk.green(`\n✓ Added ${pubkeys.length} whitelisted pubkey(s)\n`));
+    return pubkeys;
+}

package/src/commands/setup/llm.ts

@@ -0,0 +1,38 @@
+import * as fileSystem from "@/lib/fs";
+import { LLMConfigEditor } from "@/llm/LLMConfigEditor";
+import { config } from "@/services/ConfigService";
+import { logger } from "@/utils/logger";
+import { Command } from "commander";
+
+export const llmCommand = new Command("llm")
+    .description("Manage LLM configurations (global only)")
+    .action(async () => {
+        try {
+            // LLM configuration is global only
+            const globalConfigDir = config.getGlobalPath();
+
+            // Ensure global config directory exists
+            await fileSystem.ensureDirectory(globalConfigDir);
+
+            const providersConfig = await config.loadTenexProviders(globalConfigDir);
+            if (Object.keys(providersConfig.providers).length === 0) {
+                logger.error(
+                    "No providers configured. Run `tenex setup providers` before configuring LLMs."
+                );
+                process.exitCode = 1;
+                return;
+            }
+
+            const llmManager = new LLMConfigEditor();
+            await llmManager.showMainMenu();
+        } catch (error: unknown) {
+            // Handle SIGINT (Ctrl+C) gracefully - just exit without error
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage?.includes("SIGINT") || errorMessage?.includes("force closed")) {
+                return;
+            }
+            // Only show error for actual problems
+            logger.error(`Failed to start LLM configuration: ${error}`);
+            process.exitCode = 1;
+        }
+    });