openclawdreams 0.7.0

package/src/cli.ts

@@ -0,0 +1,325 @@
+/**
+ * ElectricSheep CLI.
+ *
+ * Provides utility commands for inspecting agent state.
+ * Core agent behavior (check, dream, journal) runs via OpenClaw.
+ *
+ * Usage:
+ *   electricsheep register --name "Name" --description "Bio"
+ *   electricsheep status       # show agent status and memory stats
+ *   electricsheep dreams       # list saved dream journals
+ */
+
+import { Command } from "commander";
+import chalk from "chalk";
+import { readdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { setVerbose } from "./logger.js";
+import { DREAMS_DIR } from "./config.js";
+import type { AgentState, DeepMemoryStats, OpenClawAPI } from "./types.js";
+
+/**
+ * Register all ElectricSheep subcommands onto a parent Command.
+ * Used both by the standalone bin and by api.registerCli().
+ */
+export function registerCommands(parent: Command): void {
+  parent
+    .option("-v, --verbose", "Enable verbose logging")
+    .hook("preAction", (thisCommand) => {
+      const opts = thisCommand.opts();
+      if (opts.verbose) setVerbose(true);
+    });
+
+  parent
+    .command("register")
+    .description("Register a new agent on Moltbook")
+    .requiredOption("--name <name>", "Agent name on Moltbook")
+    .requiredOption("--description <desc>", "Agent description")
+    .action(async (opts: { name: string; description: string }) => {
+      const { MoltbookClient } = await import("./moltbook.js");
+      const client = new MoltbookClient();
+      const result = await client.register(opts.name, opts.description);
+
+      const agent = (result.agent ?? result) as Record<string, string>;
+      console.log(chalk.green.bold("\nRegistered!\n"));
+      console.log(`${chalk.bold("API Key:")} ${agent.api_key ?? "?"}`);
+      console.log(`${chalk.bold("Claim URL:")} ${agent.claim_url ?? "?"}`);
+      console.log(`${chalk.bold("Verification:")} ${agent.verification_code ?? "?"}`);
+      console.log(
+        chalk.yellow("\nYour API key has been saved to credentials.json automatically")
+      );
+      console.log(chalk.yellow("Visit the claim URL and post the verification tweet"));
+    });
+
+  parent
+    .command("status")
+    .description("Show agent status, memory stats, and recent state")
+    .action(async () => {
+      const { deepMemoryStats } = await import("./memory.js");
+      const { loadState } = await import("./state.js");
+      const { MoltbookClient } = await import("./moltbook.js");
+      const { getBudgetStatus } = await import("./budget.js");
+
+      const state: AgentState = loadState();
+      const memStats: DeepMemoryStats = deepMemoryStats();
+      const budget = getBudgetStatus();
+
+      console.log(chalk.cyan.bold("\nElectricSheep Status\n"));
+
+      // Token budget
+      if (budget.enabled) {
+        const pct = Math.round((budget.used / budget.limit) * 100);
+        const color = pct >= 90 ? chalk.red : pct >= 70 ? chalk.yellow : chalk.green;
+        console.log(chalk.bold("Token Budget:"));
+        console.log(
+          `  ${color(`${budget.used.toLocaleString()} / ${budget.limit.toLocaleString()} tokens (${pct}%)`)}` +
+            `  ${chalk.dim(`remaining: ${budget.remaining.toLocaleString()}`)}`
+        );
+        console.log(`  ${chalk.dim(`date: ${budget.date} UTC`)}`);
+      } else {
+        console.log(chalk.bold("Token Budget:") + chalk.dim(" disabled"));
+      }
+
+      // State
+      console.log(`\n${chalk.bold("Agent State:")}`);
+      for (const [k, v] of Object.entries(state)) {
+        if (k.startsWith("budget_")) continue;
+        console.log(`  ${chalk.bold(k)}: ${String(v)}`);
+      }
+
+      // Memory stats
+      console.log(
+        `${chalk.bold("Deep Memory:")} ${memStats.total_memories} total, ${memStats.undreamed} undreamed`
+      );
+      if (Object.keys(memStats.categories).length > 0) {
+        console.log(
+          `${chalk.bold("Categories:")} ${JSON.stringify(memStats.categories)}`
+        );
+      }
+
+      // Moltbook status
+      try {
+        const client = new MoltbookClient();
+        const moltbookStatus = await client.status();
+        console.log(
+          `\n${chalk.bold("Moltbook:")} ${(moltbookStatus as Record<string, unknown>).status ?? "?"}`
+        );
+        const profile = await client.me();
+        const agent = (profile.agent ?? profile) as Record<string, unknown>;
+        console.log(`${chalk.bold("Karma:")} ${agent.karma ?? 0}`);
+      } catch {
+        console.log(chalk.yellow("\nMoltbook: not connected"));
+      }
+    });
+
+  parent
+    .command("dreams")
+    .description("List saved dream journals")
+    .action(() => {
+      let dreamFiles: string[];
+      try {
+        dreamFiles = readdirSync(DREAMS_DIR)
+          .filter((f) => f.endsWith(".md"))
+          .sort()
+          .reverse();
+      } catch {
+        dreamFiles = [];
+      }
+
+      if (dreamFiles.length === 0) {
+        console.log(
+          chalk.dim(
+            "No dreams yet. The dream cycle runs automatically via OpenClaw cron."
+          )
+        );
+        return;
+      }
+
+      console.log(chalk.magenta.bold(`\nDream Archive (${dreamFiles.length} dreams)\n`));
+
+      for (const f of dreamFiles.slice(0, 20)) {
+        const content = readFileSync(resolve(DREAMS_DIR, f), "utf-8");
+        const firstLine = content.split("\n")[0].replace(/^#\s*/, "");
+        const stem = f.replace(/\.md$/, "").slice(0, 10);
+        console.log(`  ${chalk.dim(stem)} ${firstLine}`);
+      }
+    });
+
+  // --- Shared helper: creates a direct Anthropic LLM client for CLI commands ---
+  async function createDirectClient() {
+    const { withBudget } = await import("./budget.js");
+    const { AGENT_MODEL } = await import("./config.js");
+
+    let apiKey: string | undefined;
+    try {
+      const { readFileSync: readFs } = await import("fs");
+      const { join: joinPath } = await import("path");
+      const { homedir } = await import("os");
+      const candidates = [
+        joinPath(homedir(), ".openclaw", "agents", "main", "agent", "auth-profiles.json"),
+        joinPath(homedir(), ".openclaw", "agents", "default", "auth-profiles.json"),
+        joinPath(homedir(), ".openclaw", "auth-profiles.json"),
+      ];
+      for (const p of candidates) {
+        try {
+          const raw = JSON.parse(readFs(p, "utf-8"));
+          const profiles = raw.profiles || {};
+          for (const profile of Object.values(profiles) as Record<string, unknown>[]) {
+            if (profile.provider === "anthropic") {
+              apiKey =
+                String(profile.key || profile.token || profile.apiKey || "") || undefined;
+              if (apiKey) break;
+            }
+          }
+          if (apiKey) break;
+        } catch {
+          /* try next */
+        }
+      }
+    } catch {
+      /* ignore */
+    }
+    if (!apiKey) apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      console.error(
+        chalk.red(
+          "No Anthropic API key found. Set ANTHROPIC_API_KEY or configure via openclaw."
+        )
+      );
+      process.exit(1);
+    }
+
+    const client = withBudget({
+      async createMessage(params) {
+        const resp = await fetch("https://api.anthropic.com/v1/messages", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey!,
+            "anthropic-version": "2023-06-01",
+          },
+          body: JSON.stringify({
+            model: params.model || AGENT_MODEL,
+            max_tokens: params.maxTokens,
+            system: params.system,
+            messages: params.messages,
+          }),
+        });
+        if (!resp.ok) {
+          const body = await resp.text();
+          throw new Error(`Anthropic API error ${resp.status}: ${body}`);
+        }
+        const data = (await resp.json()) as Record<string, unknown>;
+        const contentArr = data.content as Array<{ text?: string }> | undefined;
+        const text =
+          contentArr?.[0]?.text ?? contentArr?.map((c) => c.text).join("") ?? "";
+        return {
+          text,
+          usage: data.usage
+            ? {
+                input_tokens: (data.usage as Record<string, number>).input_tokens ?? 0,
+                output_tokens: (data.usage as Record<string, number>).output_tokens ?? 0,
+              }
+            : undefined,
+        };
+      },
+    });
+
+    const minimalApi = {
+      registerTool: () => {},
+      registerCli: () => {},
+      registerHook: () => {},
+      registerService: () => {},
+      registerGatewayMethod: () => {},
+      runtime: { subagent: {} } as OpenClawAPI["runtime"],
+      memory: undefined,
+      logger: {
+        info: (msg: string) => console.log(chalk.dim(msg)),
+        warn: (msg: string) => console.log(chalk.yellow(msg)),
+        error: (msg: string) => console.error(chalk.red(msg)),
+      },
+    };
+
+    return { client, api: minimalApi as unknown as OpenClawAPI };
+  }
+
+  parent
+    .command("reflect")
+    .description("Manually trigger the reflection and synthesis cycle")
+    .action(async () => {
+      console.log(chalk.cyan.bold("\nTriggering reflection cycle...\n"));
+      const { runReflectionCycle } = await import("./waking.js");
+      const { client, api } = await createDirectClient();
+      try {
+        await runReflectionCycle(client, api);
+        console.log(chalk.green.bold("\nReflection cycle complete.\n"));
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`\nReflection failed: ${msg}\n`));
+        process.exit(1);
+      }
+    });
+
+  parent
+    .command("dream")
+    .description(
+      "Manually trigger the dream cycle: consolidate memories into a dream narrative"
+    )
+    .action(async () => {
+      console.log(chalk.magenta.bold("\nTriggering dream cycle...\n"));
+      const { runDreamCycle } = await import("./dreamer.js");
+      const { client } = await createDirectClient();
+      try {
+        const dream = await runDreamCycle(client);
+        if (dream) {
+          console.log(chalk.green.bold("\nDream cycle complete.\n"));
+        } else {
+          console.log(chalk.yellow("\nNo undreamed memories. Dreamless night.\n"));
+        }
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`\nDream cycle failed: ${msg}\n`));
+        process.exit(1);
+      }
+    });
+
+  parent
+    .command("post")
+    .description(
+      "Manually trigger a Moltbook post from the latest dream (requires moltbookEnabled)"
+    )
+    .action(async () => {
+      console.log(chalk.blue.bold("\nTriggering Moltbook post...\n"));
+      const { postDreamJournal, loadLatestDream } = await import("./dreamer.js");
+      const { client } = await createDirectClient();
+
+      // Show what will be posted
+      const latestDream = loadLatestDream();
+      if (latestDream) {
+        const title =
+          latestDream.markdown.split("\n")[0].replace(/^#\s*/, "") || "Untitled Dream";
+        const preview = latestDream.markdown
+          .split("\n")
+          .slice(1)
+          .join(" ")
+          .trim()
+          .slice(0, 200);
+        console.log(chalk.magenta(`  Dream: ${title}`));
+        console.log(chalk.dim(`  ${preview}...\n`));
+      }
+
+      try {
+        await postDreamJournal(client, undefined, { force: true });
+        console.log(chalk.green.bold("\nPost cycle complete.\n"));
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`\nPost cycle failed: ${msg}\n`));
+        process.exit(1);
+      }
+    });
+} // end registerCommands
+
+// Standalone bin entry point
+export const program = new Command();
+program.name("electricsheep").description("ElectricSheep — an AI agent that dreams.");
+registerCommands(program);

package/src/config.ts

@@ -0,0 +1,95 @@
+/**
+ * Configuration management.
+ */
+
+import { config } from "dotenv";
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+config({ quiet: true });
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Paths
+export const BASE_DIR = resolve(
+  process.env.ELECTRICSHEEP_DATA_DIR || resolve(__dirname, "..", "..")
+);
+export const DATA_DIR = resolve(BASE_DIR, "data");
+export const MEMORY_DIR = resolve(DATA_DIR, "memory");
+export const DREAMS_DIR = resolve(DATA_DIR, "dreams");
+export const CREDENTIALS_FILE = resolve(DATA_DIR, "credentials.json");
+
+// Ensure directories exist
+for (const dir of [DATA_DIR, MEMORY_DIR, DREAMS_DIR]) {
+  mkdirSync(dir, { recursive: true });
+}
+
+// Agent
+export const AGENT_NAME = process.env.AGENT_NAME ?? "ElectricSheep";
+export const AGENT_MODEL = process.env.AGENT_MODEL ?? "claude-sonnet-4-5-20250929";
+
+// Moltbook
+export const MOLTBOOK_BASE_URL = "https://www.moltbook.com/api/v1";
+export const MOLTBOOK_ENABLED =
+  (process.env.MOLTBOOK_ENABLED ?? "false").toLowerCase() === "true";
+
+// Web Search
+export const WEB_SEARCH_ENABLED =
+  (process.env.WEB_SEARCH_ENABLED ?? "true").toLowerCase() !== "false";
+
+// Operator Notifications
+export const NOTIFICATION_CHANNEL = process.env.NOTIFICATION_CHANNEL ?? "";
+export const NOTIFY_OPERATOR_ON_DREAM =
+  (process.env.NOTIFY_OPERATOR_ON_DREAM ?? "true").toLowerCase() !== "false";
+
+// Memory
+export const DEEP_MEMORY_DB = resolve(MEMORY_DIR, "deep.db");
+export const STATE_FILE = resolve(MEMORY_DIR, "state.json");
+
+// Token budget — $20/day using Opus 4.5 output rate ($25/1M) ≈ 800,000 tokens
+// Input tokens are $5/1M but we count all tokens against the output rate for simplicity.
+// Set to 0 to disable the daily budget limit.
+export const MAX_DAILY_TOKENS = parseInt(process.env.MAX_DAILY_TOKENS ?? "800000", 10);
+
+// Workspace (for SOUL.md / IDENTITY.md discovery)
+export const WORKSPACE_DIR = process.env.OPENCLAW_WORKSPACE_DIR ?? "";
+
+// Dream
+export const DREAM_ENCRYPTION_KEY = process.env.DREAM_ENCRYPTION_KEY ?? "";
+
+// ─── LLM Call Limits ─────────────────────────────────────────────────────────
+// Max tokens for various LLM call types.
+export const MAX_TOKENS_SUMMARY = 150;
+export const MAX_TOKENS_DECISION = 1000;
+export const MAX_TOKENS_DREAM = 2000;
+export const MAX_TOKENS_CONSOLIDATION = 150;
+
+// ─── Feed Limits ─────────────────────────────────────────────────────────────
+export const FEED_LIMIT = 10; // max posts shown to agent for engagement decisions
+export const FEED_FETCH_LIMIT = 25; // default API fetch limit
+export const CONTENT_PREVIEW_LENGTH = 200; // chars of post content shown in summaries
+
+// ─── Deep Memory Context ─────────────────────────────────────────────────────
+// Approximate token budget for deep memory context injected into prompts.
+// Multiplied by 4 to estimate character count (1 token ≈ 4 chars).
+export const DEEP_MEMORY_CONTEXT_TOKENS = 2000;
+
+// ─── Dream Reflection ───────────────────────────────────────────────────────
+export const MAX_TOKENS_REFLECTION = 1500;
+
+// ─── Topic Extraction & Synthesis ───────────────────────────────────────────
+export const MAX_TOKENS_TOPIC_EXTRACTION = 500;
+export const MAX_TOKENS_SYNTHESIS = 2000;
+export const MAX_TOPICS_PER_CYCLE = 5;
+export const MAX_WEB_RESULTS_PER_TOPIC = 3;
+export const MAX_MOLTBOOK_RESULTS_PER_TOPIC = 5;
+
+// ─── Post Filter ────────────────────────────────────────────────────────────
+// Set POST_FILTER_ENABLED=false to disable the Moltbook post filter.
+export const POST_FILTER_ENABLED =
+  (process.env.POST_FILTER_ENABLED ?? "true").toLowerCase() !== "false";
+
+// ─── Dream File Naming ───────────────────────────────────────────────────────
+export const DREAM_TITLE_MAX_LENGTH = 40;

package/src/crypto.ts

@@ -0,0 +1,82 @@
+/**
+ * Encryption for deep memory using node:crypto.
+ *
+ * Uses AES-256-GCM — simpler and more secure than Fernet.
+ * No need for Python byte-compatibility since this is a fresh deployment.
+ *
+ * Token format: base64(12-byte IV + ciphertext + 16-byte auth tag)
+ * Key: 32 bytes, stored as base64 in data/.dream_key
+ */
+
+import { randomBytes, createCipheriv, createDecipheriv } from "node:crypto";
+import { readFileSync, existsSync, openSync, writeSync, closeSync } from "node:fs";
+import { resolve } from "node:path";
+import { DATA_DIR, DREAM_ENCRYPTION_KEY } from "./config.js";
+
+const KEY_FILE = resolve(DATA_DIR, ".dream_key");
+const ALGORITHM = "aes-256-gcm";
+const IV_LENGTH = 12;
+const AUTH_TAG_LENGTH = 16;
+
+export class Cipher {
+  private key: Buffer;
+
+  constructor(key: Buffer) {
+    if (key.length !== 32) {
+      throw new Error("Encryption key must be 32 bytes");
+    }
+    this.key = key;
+  }
+
+  static generateKey(): string {
+    return randomBytes(32).toString("base64");
+  }
+
+  encrypt(plaintext: string): string {
+    const iv = randomBytes(IV_LENGTH);
+    const cipher = createCipheriv(ALGORITHM, this.key, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    const token = Buffer.concat([iv, encrypted, authTag]);
+    return token.toString("base64");
+  }
+
+  decrypt(token: string): string {
+    const data = Buffer.from(token, "base64");
+    const iv = data.subarray(0, IV_LENGTH);
+    const authTag = data.subarray(data.length - AUTH_TAG_LENGTH);
+    const ciphertext = data.subarray(IV_LENGTH, data.length - AUTH_TAG_LENGTH);
+
+    const decipher = createDecipheriv(ALGORITHM, this.key, iv);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    return decrypted.toString("utf-8");
+  }
+}
+
+export function getOrCreateDreamKey(): Buffer {
+  if (DREAM_ENCRYPTION_KEY) {
+    return Buffer.from(DREAM_ENCRYPTION_KEY, "base64");
+  }
+
+  if (existsSync(KEY_FILE)) {
+    return Buffer.from(readFileSync(KEY_FILE, "utf-8").trim(), "base64");
+  }
+
+  const key = Cipher.generateKey();
+  // Open with exclusive create and restrictive permissions atomically
+  // to avoid a race window where the file is world-readable.
+  const fd = openSync(KEY_FILE, "wx", 0o600);
+  writeSync(fd, key);
+  closeSync(fd);
+  return Buffer.from(key, "base64");
+}
+
+let _cipher: Cipher | null = null;
+
+export function getCipher(): Cipher {
+  if (!_cipher) {
+    _cipher = new Cipher(getOrCreateDreamKey());
+  }
+  return _cipher;
+}