@tenex-chat/backend 0.9.1

package/src/commands/agent/import/openclaw-reader.ts

@@ -0,0 +1,141 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { homedir } from "node:os";
+
+export interface OpenClawWorkspaceFiles {
+    soul: string | null;
+    identity: string | null;
+    agents: string | null;
+    user: string | null;
+}
+
+export interface OpenClawAgent {
+    id: string;
+    modelPrimary: string;
+    workspacePath: string;
+    workspaceFiles: OpenClawWorkspaceFiles;
+}
+
+async function readFileOrNull(filePath: string): Promise<string | null> {
+    try {
+        return await fs.readFile(filePath, "utf-8");
+    } catch {
+        return null;
+    }
+}
+
+const CONFIG_FILE_NAMES = ["openclaw.json", "clawdbot.json", "moldbot.json", "moltbot.json"] as const;
+
+async function configExists(dir: string): Promise<boolean> {
+    for (const name of CONFIG_FILE_NAMES) {
+        try {
+            await fs.access(path.join(dir, name));
+            return true;
+        } catch {
+            // continue
+        }
+    }
+    return false;
+}
+
+export async function findOpenClawStateDir(candidatePaths: string[]): Promise<string | null> {
+    // 1. Environment variable takes precedence
+    const envDir = process.env.OPENCLAW_STATE_DIR;
+    if (envDir && (await configExists(envDir))) {
+        return envDir;
+    }
+
+    // 2. Check candidate paths
+    for (const dir of candidatePaths) {
+        if (await configExists(dir)) {
+            return dir;
+        }
+    }
+
+    return null;
+}
+
+export async function detectOpenClawStateDir(): Promise<string | null> {
+    const home = homedir();
+    return findOpenClawStateDir([
+        path.join(home, ".openclaw"),
+        path.join(home, ".clawdbot"),
+        path.join(home, ".moldbot"),
+        path.join(home, ".moltbot"),
+    ]);
+}
+
+async function readConfigJson(stateDir: string): Promise<Record<string, unknown>> {
+    for (const name of CONFIG_FILE_NAMES) {
+        try {
+            const content = await fs.readFile(path.join(stateDir, name), "utf-8");
+            return JSON.parse(content);
+        } catch {
+            // continue
+        }
+    }
+    throw new Error(`No config file found in ${stateDir}`);
+}
+
+async function readWorkspaceFiles(workspacePath: string): Promise<OpenClawWorkspaceFiles> {
+    const [soul, identity, agents, user] = await Promise.all([
+        readFileOrNull(path.join(workspacePath, "SOUL.md")),
+        readFileOrNull(path.join(workspacePath, "IDENTITY.md")),
+        readFileOrNull(path.join(workspacePath, "AGENTS.md")),
+        readFileOrNull(path.join(workspacePath, "USER.md")),
+    ]);
+    return { soul, identity, agents, user };
+}
+
+export async function readOpenClawAgents(stateDir: string): Promise<OpenClawAgent[]> {
+    const config = await readConfigJson(stateDir);
+    const agentsConfig = (config.agents ?? {}) as Record<string, unknown>;
+    const defaults = (agentsConfig.defaults ?? {}) as Record<string, unknown>;
+    const defaultModel = ((defaults.model ?? {}) as Record<string, unknown>).primary as
+        | string
+        | undefined;
+    const defaultWorkspace =
+        (defaults.workspace as string | undefined) ?? path.join(stateDir, "workspace");
+
+    const list = agentsConfig.list as Array<Record<string, unknown>> | undefined;
+
+    if (!list || list.length === 0) {
+        // Single default "main" agent
+        const workspaceFiles = await readWorkspaceFiles(defaultWorkspace);
+        return [
+            {
+                id: "main",
+                modelPrimary: defaultModel ?? "anthropic/claude-sonnet-4-6",
+                workspacePath: defaultWorkspace,
+                workspaceFiles,
+            },
+        ];
+    }
+
+    return Promise.all(
+        list.map(async (entry) => {
+            const id = (entry.id as string | undefined) ?? "main";
+            const agentModel = ((entry.model ?? {}) as Record<string, unknown>).primary as
+                | string
+                | undefined;
+            const workspacePath = (entry.workspace as string | undefined) ?? defaultWorkspace;
+            const workspaceFiles = await readWorkspaceFiles(workspacePath);
+            return {
+                id,
+                modelPrimary: agentModel ?? defaultModel ?? "anthropic/claude-sonnet-4-6",
+                workspacePath,
+                workspaceFiles,
+            };
+        })
+    );
+}
+
+/**
+ * Convert OpenClaw model format to TENEX format.
+ * OpenClaw uses "provider/model", TENEX uses "provider:model".
+ */
+export function convertModelFormat(openClawModel: string): string {
+    const firstSlash = openClawModel.indexOf("/");
+    if (firstSlash === -1) return openClawModel;
+    return openClawModel.slice(0, firstSlash) + ":" + openClawModel.slice(firstSlash + 1);
+}

package/src/commands/agent/import/openclaw.ts

@@ -0,0 +1,154 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { Command } from "commander";
+import chalk from "chalk";
+import { NDKPrivateKeySigner } from "@nostr-dev-kit/ndk";
+import { agentStorage, createStoredAgent } from "@/agents/AgentStorage";
+import { config as configService } from "@/services/ConfigService";
+import type { LLMConfiguration } from "@/services/config/types";
+import { detectOpenClawStateDir, readOpenClawAgents, convertModelFormat } from "./openclaw-reader";
+import { distillAgentIdentity } from "./openclaw-distiller";
+import type { OpenClawAgent } from "./openclaw-reader";
+
+function toSlug(name: string): string {
+    return name
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+
+async function createHomeDir(pubkey: string, workspacePath: string): Promise<string> {
+    const homeDir = configService.getConfigPath(`agents/${pubkey}`);
+    await fs.mkdir(homeDir, { recursive: true });
+
+    // Symlink MEMORY.md (dangling is ok — file may not exist yet)
+    const memoryMdTarget = path.join(workspacePath, "MEMORY.md");
+    const memoryMdLink = path.join(homeDir, "MEMORY.md");
+    await fs.rm(memoryMdLink, { force: true });
+    await fs.symlink(memoryMdTarget, memoryMdLink);
+
+    // Symlink memory/ directory (dangling is ok)
+    const memoryDirTarget = path.join(workspacePath, "memory");
+    const memoryDirLink = path.join(homeDir, "memory");
+    await fs.rm(memoryDirLink, { force: true });
+    await fs.symlink(memoryDirTarget, memoryDirLink);
+
+    const indexContent = `# Memory Files
+
+This agent's memory is synced live from an OpenClaw installation.
+
+- \`MEMORY.md\` — long-term curated memory (updated by OpenClaw)
+- \`memory/YYYY-MM-DD.md\` — daily session logs (updated by OpenClaw)
+
+Source: ${workspacePath}
+`;
+    await fs.writeFile(path.join(homeDir, "+INDEX.md"), indexContent, "utf-8");
+
+    return homeDir;
+}
+
+async function appendUserMdToGlobalPrompt(userMdContent: string): Promise<void> {
+    const globalPath = configService.getGlobalPath();
+    const existingConfig = await configService.loadTenexConfig(globalPath);
+
+    const userSection = `\n## About the User (imported from OpenClaw)\n\n${userMdContent.trim()}`;
+    const existingContent = existingConfig.globalSystemPrompt?.content ?? "";
+    const newContent = existingContent ? `${existingContent}${userSection}` : userSection.trim();
+
+    const newConfig = {
+        ...existingConfig,
+        globalSystemPrompt: {
+            enabled: true,
+            content: newContent,
+        },
+    };
+    await configService.saveGlobalConfig(newConfig);
+}
+
+async function importOneAgent(agent: OpenClawAgent, llmConfig: LLMConfiguration): Promise<void> {
+    const tenexModel = convertModelFormat(agent.modelPrimary);
+
+    console.log(chalk.blue(`\nDistilling identity for agent '${agent.id}'...`));
+    const identity = await distillAgentIdentity(agent.workspaceFiles, llmConfig);
+
+    const slug = toSlug(identity.name) || agent.id;
+
+    const slugTaken = await agentStorage.slugExists(slug);
+    if (slugTaken) {
+        throw new Error(
+            `Agent '${slug}' already imported. Delete it first if you want to re-import.`
+        );
+    }
+
+    const signer = NDKPrivateKeySigner.generate();
+    const pubkey = signer.pubkey;
+
+    const storedAgent = createStoredAgent({
+        nsec: signer.privateKey,
+        slug,
+        name: identity.name,
+        role: identity.role,
+        description: identity.description,
+        instructions: identity.instructions,
+        useCriteria: identity.useCriteria,
+        defaultConfig: { model: tenexModel },
+    });
+
+    await agentStorage.saveAgent(storedAgent);
+    const homeDir = await createHomeDir(pubkey, agent.workspacePath);
+
+    console.log(chalk.green(`  ✓ Imported: ${identity.name} (${slug})`));
+    console.log(chalk.gray(`    Keypair:   ${pubkey}`));
+    console.log(chalk.gray(`    Model:     ${tenexModel}`));
+    console.log(chalk.gray(`    Home dir:  ${homeDir}`));
+    console.log(chalk.gray(`    Symlinks:  MEMORY.md, memory/`));
+}
+
+export const openclawImportCommand = new Command("openclaw")
+    .description("Import agents from a local OpenClaw installation")
+    .action(async () => {
+        try {
+            const stateDir = await detectOpenClawStateDir();
+            if (!stateDir) {
+                console.error(chalk.red("No OpenClaw installation detected."));
+                console.error(
+                    chalk.gray(
+                        "Checked: $OPENCLAW_STATE_DIR, ~/.openclaw, ~/.clawdbot, ~/.moldbot, ~/.moltbot"
+                    )
+                );
+                process.exitCode = 1;
+                return;
+            }
+
+            console.log(chalk.blue(`Found OpenClaw installation at: ${stateDir}`));
+
+            const agents = await readOpenClawAgents(stateDir);
+            console.log(chalk.blue(`Found ${agents.length} agent(s) to import.`));
+
+            await configService.loadConfig();
+            await agentStorage.initialize();
+
+            const llmConfig = configService.getLLMConfig();
+            let userMdProcessed = false;
+
+            for (const agent of agents) {
+                await importOneAgent(agent, llmConfig);
+
+                if (!userMdProcessed && agent.workspaceFiles.user) {
+                    await appendUserMdToGlobalPrompt(agent.workspaceFiles.user);
+                    console.log(chalk.green("  ✓ USER.md appended to global system prompt"));
+                    userMdProcessed = true;
+                }
+            }
+
+            console.log(chalk.green("\nImport complete."));
+        } catch (error: unknown) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage?.includes("SIGINT") || errorMessage?.includes("force closed")) {
+                return;
+            }
+            console.error(chalk.red(`Import failed: ${errorMessage}`));
+            process.exitCode = 1;
+        }
+    });

package/src/commands/agent/index.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+import { importCommand } from "./import/index";
+
+export const agentCommand = new Command("agent")
+    .description("Agent management commands")
+    .addCommand(importCommand);

package/src/commands/agent.ts

@@ -0,0 +1,215 @@
+import * as fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+import { Command } from "commander";
+import chalk from "chalk";
+import { NDKPrivateKeySigner, NDKEvent } from "@nostr-dev-kit/ndk";
+import { agentStorage, createStoredAgent } from "@/agents/AgentStorage";
+import { installAgentFromNostr, installAgentFromNostrEvent } from "@/agents/agent-installer";
+import { initNDK } from "@/nostr/ndkClient";
+
+// ─── OpenClaw discovery ──────────────────────────────────────────────────────
+
+const OPENCLAW_STATE_DIR_NAMES = [".openclaw", ".clawdbot", ".moldbot", ".moltbot"];
+const OPENCLAW_CONFIG_NAMES = ["openclaw.json", "clawdbot.json", "moldbot.json", "moltbot.json"];
+
+function findOpenClawStateDir(): string | undefined {
+    // 1. Environment variable
+    const envPath = process.env.OPENCLAW_STATE_DIR;
+    if (envPath && hasOpenClawConfig(envPath)) {
+        return envPath;
+    }
+
+    // 2. Home directory candidates
+    const home = homedir();
+    for (const name of OPENCLAW_STATE_DIR_NAMES) {
+        const candidate = path.join(home, name);
+        if (hasOpenClawConfig(candidate)) {
+            return candidate;
+        }
+    }
+
+    return undefined;
+}
+
+function hasOpenClawConfig(dir: string): boolean {
+    return OPENCLAW_CONFIG_NAMES.some((name) => existsSync(path.join(dir, name)));
+}
+
+/** Prettify a slug for display: "main" → "Main", "my-agent" → "My Agent" */
+function prettifySlug(slug: string): string {
+    return slug
+        .replace(/-/g, " ")
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+interface OpenClawAgent {
+    name: string;
+    slug: string;
+    role: string;
+}
+
+async function discoverOpenClawAgents(stateDir: string): Promise<OpenClawAgent[]> {
+    const agentsDir = path.join(stateDir, "agents");
+    try {
+        const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isDirectory())
+            .map((e) => ({
+                name: prettifySlug(e.name),
+                slug: e.name,
+                role: "",
+            }));
+    } catch {
+        return [];
+    }
+}
+
+// ─── tenex agent import openclaw ────────────────────────────────────────────
+
+async function importOpenClaw(options: {
+    dryRun: boolean;
+    json: boolean;
+    slugs?: string;
+}): Promise<void> {
+    const stateDir = findOpenClawStateDir();
+
+    if (!stateDir) {
+        if (options.json) {
+            console.log("[]");
+        } else {
+            console.error(chalk.yellow("OpenClaw installation not found."));
+        }
+        return;
+    }
+
+    const agents = await discoverOpenClawAgents(stateDir);
+
+    // Apply slug filter if provided
+    const filtered =
+        options.slugs
+            ? agents.filter((a) => options.slugs!.split(",").map((s) => s.trim()).includes(a.slug))
+            : agents;
+
+    if (options.json) {
+        console.log(JSON.stringify(filtered, null, 2));
+        return;
+    }
+
+    if (filtered.length === 0) {
+        console.log(chalk.yellow("No OpenClaw agents found."));
+        return;
+    }
+
+    if (options.dryRun) {
+        console.log(chalk.blue(`Would import ${filtered.length} OpenClaw agent(s):`));
+        for (const agent of filtered) {
+            console.log(chalk.gray(`  ${agent.slug} → "${agent.name}"`));
+        }
+        return;
+    }
+
+    await agentStorage.initialize();
+
+    let imported = 0;
+    let skipped = 0;
+
+    for (const agent of filtered) {
+        // Check if already exists by slug
+        const existing = await agentStorage.getAgentBySlug(agent.slug);
+        if (existing) {
+            console.log(chalk.gray(`  ${agent.slug}: already exists, skipping`));
+            skipped++;
+            continue;
+        }
+
+        const signer = NDKPrivateKeySigner.generate();
+        const stored = createStoredAgent({
+            nsec: signer.nsec,
+            slug: agent.slug,
+            name: agent.name,
+            role: agent.role,
+        });
+
+        await agentStorage.saveAgent(stored);
+        console.log(
+            chalk.green(`  ✓ ${agent.slug}`) +
+            chalk.gray(` → pubkey ${signer.pubkey.substring(0, 8)}...`)
+        );
+        imported++;
+    }
+
+    console.log(chalk.blue(`\nDone: ${imported} imported, ${skipped} skipped`));
+}
+
+// ─── tenex agent add ─────────────────────────────────────────────────────────
+
+async function readStdin(): Promise<string> {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data.trim()));
+        process.stdin.on("error", reject);
+    });
+}
+
+async function addAgent(eventId: string | undefined): Promise<void> {
+    await agentStorage.initialize();
+
+    if (!process.stdin.isTTY) {
+        const raw = await readStdin();
+        const rawEvent = JSON.parse(raw);
+        const event = new NDKEvent(undefined, rawEvent);
+        const stored = await installAgentFromNostrEvent(event);
+        const pubkey = new NDKPrivateKeySigner(stored.nsec).pubkey;
+        console.log(chalk.green(`✓ Installed agent "${stored.name}" (${stored.slug})`));
+        console.log(chalk.gray(`  pubkey: ${pubkey}`));
+        return;
+    }
+
+    if (!eventId) {
+        console.error(chalk.red("Error: provide an event ID or pipe event JSON via stdin"));
+        process.exit(1);
+    }
+
+    await initNDK();
+    const stored = await installAgentFromNostr(eventId);
+    const pubkey = new NDKPrivateKeySigner(stored.nsec).pubkey;
+    console.log(chalk.green(`✓ Installed agent "${stored.name}" (${stored.slug})`));
+    console.log(chalk.gray(`  pubkey: ${pubkey}`));
+}
+
+// ─── Command registration ────────────────────────────────────────────────────
+
+const importOpenClawCommand = new Command("openclaw")
+    .description("Import agents from a local OpenClaw installation")
+    .option("--dry-run", "Print what would be imported without making changes")
+    .option("--json", "Output as JSON array")
+    .option("--slugs <slugs>", "Comma-separated list of slugs to import (default: all)")
+    .action(async (options) => {
+        await importOpenClaw({
+            dryRun: !!options.dryRun,
+            json: !!options.json,
+            slugs: options.slugs,
+        });
+    });
+
+const importCommand = new Command("import")
+    .description("Import agents from external sources")
+    .addCommand(importOpenClawCommand);
+
+const addCommand = new Command("add")
+    .description("Install an agent from a Nostr event ID or stdin JSON")
+    .argument("[event-id]", "Nostr event ID of the agent definition")
+    .action(async (eventId: string | undefined) => {
+        await addAgent(eventId);
+    });
+
+export const agentCommand = new Command("agent")
+    .description("Manage TENEX agents")
+    .addCommand(importCommand)
+    .addCommand(addCommand);