npm - @rubytech/create-maxy - Versions diffs - 1.0.0 - Mend

@rubytech/create-maxy 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (181) hide show

package/payload/maxy/app/layout.tsx ADDED Viewed

@@ -0,0 +1,58 @@
+import type { Metadata } from 'next'
+import { Cormorant, DM_Sans } from 'next/font/google'
+import './globals.css'
+const cormorant = Cormorant({
+  subsets: ['latin'],
+  weight: ['300', '400', '500'],
+  variable: '--font-display',
+  display: 'swap',
+})
+const dmSans = DM_Sans({
+  subsets: ['latin'],
+  weight: ['400', '500'],
+  variable: '--font-body',
+  display: 'swap',
+})
+export const metadata: Metadata = {
+  title: 'Maxy — AI for Productive People.',
+  description: 'A personal AI assistant that lives in your home. Your data never leaves.',
+  icons: {
+    icon: '/favicon.ico',
+    apple: '/apple-icon.png',
+  },
+  openGraph: {
+    title: 'Maxy — AI for Productive People.',
+    description: 'A personal AI assistant that lives in your home. Your data never leaves.',
+    siteName: 'Maxy',
+    type: 'website',
+    images: [
+      {
+        url: '/og-landscape.png',
+        width: 1200,
+        height: 628,
+        alt: 'Maxy — AI for Productive People.',
+      },
+    ],
+  },
+  twitter: {
+    card: 'summary_large_image',
+    title: 'Maxy — AI for Productive People.',
+    description: 'A personal AI assistant that lives in your home. Your data never leaves.',
+    images: ['/og-landscape.png'],
+  },
+}
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  return (
+    <html lang="en" className={`${cormorant.variable} ${dmSans.variable}`}>
+      <body>{children}</body>
+    </html>
+  )
+}

package/payload/maxy/app/lib/claude-agent.ts ADDED Viewed

@@ -0,0 +1,503 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+import { readFileSync, readdirSync, existsSync, mkdirSync, createWriteStream } from "node:fs";
+import { homedir } from "node:os";
+const LOG_DIR = resolve(homedir(), ".maxy/logs");
+function agentLogStream(name: string) {
+  mkdirSync(LOG_DIR, { recursive: true });
+  return createWriteStream(resolve(LOG_DIR, `${name}.log`), { flags: "a" });
+}
+// Load ANTHROPIC_API_KEY from persistent storage if not already in env.
+// Written by the admin agent during onboarding.
+if (!process.env.ANTHROPIC_API_KEY) {
+  const keyFile = resolve(homedir(), ".maxy/.anthropic-api-key");
+  if (existsSync(keyFile)) {
+    try {
+      process.env.ANTHROPIC_API_KEY = readFileSync(keyFile, "utf-8").trim();
+    } catch { /* ignore */ }
+  }
+}
+const PLATFORM_ROOT = resolve(process.cwd(), "../platform");
+const ACCOUNTS_DIR = resolve(PLATFORM_ROOT, "config/accounts");
+// ---------------------------------------------------------------------------
+// Account resolution
+// ---------------------------------------------------------------------------
+interface AccountConfig {
+  accountId: string;
+  tier: string;
+  name: string;
+  description: string;
+  domains: { public: string; admin: string };
+  brand: Record<string, string>;
+  telegram: { publicBotToken: string };
+}
+/**
+ * Find the first account on this device.
+ * Phase 0: single account. Multi-account resolution is a Phase 1 concern.
+ */
+function resolveAccount(): { accountId: string; accountDir: string; config: AccountConfig } | null {
+  if (!existsSync(ACCOUNTS_DIR)) return null;
+  const entries = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const configPath = resolve(ACCOUNTS_DIR, entry.name, "account.json");
+    if (!existsSync(configPath)) continue;
+    const raw = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw) as AccountConfig;
+    return {
+      accountId: config.accountId,
+      accountDir: resolve(ACCOUNTS_DIR, entry.name),
+      config,
+    };
+  }
+  return null;
+}
+/**
+ * Read the IDENTITY.md for a specific agent within an account.
+ */
+function readIdentity(accountDir: string, agentName: string): string | null {
+  const identityPath = resolve(accountDir, "agents", agentName, "IDENTITY.md");
+  if (!existsSync(identityPath)) return null;
+  return readFileSync(identityPath, "utf-8");
+}
+// ---------------------------------------------------------------------------
+// Session store
+// ---------------------------------------------------------------------------
+const sessionStore = new Map<
+  string,
+  { agentSessionId?: string; createdAt: number; agentType: "public" | "admin"; accountId: string }
+>();
+export function registerSession(
+  sessionKey: string,
+  agentType: "public" | "admin",
+  accountId: string
+): void {
+  sessionStore.set(sessionKey, { createdAt: Date.now(), agentType, accountId });
+}
+export function validateSession(
+  sessionKey: string,
+  agentType: "public" | "admin"
+): boolean {
+  const session = sessionStore.get(sessionKey);
+  if (!session) return false;
+  if (session.agentType !== agentType) return false;
+  if (Date.now() - session.createdAt > 24 * 60 * 60 * 1000) {
+    sessionStore.delete(sessionKey);
+    return false;
+  }
+  return true;
+}
+function storeAgentSessionId(sessionKey: string, agentSessionId: string): void {
+  const session = sessionStore.get(sessionKey);
+  if (session) {
+    session.agentSessionId = agentSessionId;
+  }
+}
+function getAgentSessionId(sessionKey: string): string | undefined {
+  return sessionStore.get(sessionKey)?.agentSessionId;
+}
+function getAccountIdForSession(sessionKey: string): string | undefined {
+  return sessionStore.get(sessionKey)?.accountId;
+}
+// ---------------------------------------------------------------------------
+// MCP server configuration (admin agent only)
+// ---------------------------------------------------------------------------
+function getMcpServers(accountId: string) {
+  return {
+    "memory": {
+      command: "node",
+      args: [resolve(PLATFORM_ROOT, "plugins/memory/mcp/dist/index.js")],
+      env: { ACCOUNT_ID: accountId, PLATFORM_ROOT },
+    },
+    "contacts": {
+      command: "node",
+      args: [resolve(PLATFORM_ROOT, "plugins/contacts/mcp/dist/index.js")],
+      env: { ACCOUNT_ID: accountId, PLATFORM_ROOT },
+    },
+    "telegram": {
+      command: "node",
+      args: [resolve(PLATFORM_ROOT, "plugins/telegram/mcp/dist/index.js")],
+      env: { ACCOUNT_ID: accountId, PLATFORM_ROOT },
+    },
+    "admin": {
+      command: "node",
+      args: [resolve(PLATFORM_ROOT, "plugins/admin/mcp/dist/index.js")],
+      env: { ACCOUNT_ID: accountId, PLATFORM_ROOT },
+    },
+    "cloudflare": {
+      command: "node",
+      args: [resolve(PLATFORM_ROOT, "plugins/cloudflare/mcp/dist/index.js")],
+      env: { PLATFORM_ROOT },
+    },
+    "scheduling": {
+      command: "node",
+      args: [resolve(PLATFORM_ROOT, "plugins/scheduling/mcp/dist/index.js")],
+      env: { PLATFORM_ROOT },
+    },
+    "documents": {
+      command: "node",
+      args: [resolve(PLATFORM_ROOT, "plugins/documents/mcp/dist/index.js")],
+      env: { PLATFORM_ROOT },
+    },
+    "web": {
+      command: "node",
+      args: [resolve(PLATFORM_ROOT, "plugins/web/mcp/dist/index.js")],
+      env: { PLATFORM_ROOT },
+    },
+  };
+}
+const ADMIN_ALLOWED_TOOLS = [
+  "Read", "Write", "Edit", "Bash", "Glob", "Grep", "Agent",
+  "mcp__memory__memory-search",
+  "mcp__memory__memory-write",
+  "mcp__memory__memory-reindex",
+  "mcp__contacts__contact-create",
+  "mcp__contacts__contact-lookup",
+  "mcp__contacts__contact-update",
+  "mcp__contacts__contact-list",
+  "mcp__telegram__message",
+  "mcp__telegram__message-history",
+  "mcp__admin__system-status",
+  "mcp__admin__brand-settings",
+  "mcp__admin__account-manage",
+  "mcp__admin__logs-read",
+  "mcp__admin__plugin-read",
+  "mcp__cloudflare__tunnel-status",
+  "mcp__cloudflare__tunnel-install",
+  "mcp__cloudflare__tunnel-login",
+  "mcp__cloudflare__tunnel-create",
+  "mcp__cloudflare__tunnel-enable",
+  "mcp__cloudflare__tunnel-disable",
+];
+// ---------------------------------------------------------------------------
+// Memory pre-fetch for public agent
+// ---------------------------------------------------------------------------
+/**
+ * Call the memory MCP server via JSON-RPC to search for relevant context.
+ * Returns a formatted string of results, or null if the server is unavailable.
+ */
+async function fetchMemoryContext(accountId: string, query: string): Promise<string | null> {
+  const serverPath = resolve(PLATFORM_ROOT, "plugins/memory/mcp/dist/index.js");
+  if (!existsSync(serverPath)) return null;
+  return new Promise((resolve) => {
+    const proc = spawn(process.execPath, [serverPath], {
+      env: { ...process.env, ACCOUNT_ID: accountId, READ_ONLY: "true" },
+    });
+    let buffer = "";
+    let settled = false;
+    const TOOL_CALL_ID = 2;
+    const settle = (value: string | null) => {
+      if (settled) return;
+      settled = true;
+      proc.kill();
+      resolve(value);
+    };
+    proc.stdout.on("data", (chunk: Buffer) => {
+      buffer += chunk.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        let msg: Record<string, unknown>;
+        try { msg = JSON.parse(line); } catch { continue; }
+        if (msg.id === 1) {
+          // Server initialised — send initialized notification then tool call
+          proc.stdin.write(
+            JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n"
+          );
+          proc.stdin.write(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: TOOL_CALL_ID,
+              method: "tools/call",
+              params: { name: "memory-search", arguments: { query, account_id: accountId } },
+            }) + "\n"
+          );
+        } else if (msg.id === TOOL_CALL_ID) {
+          const result = msg.result as Record<string, unknown> | undefined;
+          const content = result?.content as Array<{ type: string; text?: string }> | undefined;
+          const text = content?.find((c) => c.type === "text")?.text ?? null;
+          settle(text);
+        }
+      }
+    });
+    proc.on("error", () => settle(null));
+    proc.on("close", () => settle(null));
+    // Send MCP initialize
+    proc.stdin.write(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "maxy-site", version: "1.0" },
+        },
+      }) + "\n"
+    );
+    // Timeout after 8 seconds
+    setTimeout(() => settle(null), 8000);
+  });
+}
+// ---------------------------------------------------------------------------
+// Admin agent: Claude Code CLI subprocess
+// ---------------------------------------------------------------------------
+async function* invokeAdminAgent(
+  message: string,
+  systemPrompt: string,
+  accountDir: string,
+  accountId: string,
+  sessionKey?: string
+): AsyncGenerator<AgentStreamEvent> {
+  const resumeSessionId = sessionKey ? getAgentSessionId(sessionKey) : undefined;
+  const mcpConfig = JSON.stringify({ mcpServers: getMcpServers(accountId) });
+  const args = [
+    "--print",
+    "--output-format", "stream-json",
+    "--verbose",
+    "--system-prompt", systemPrompt,
+    "--mcp-config", mcpConfig,
+    "--allowedTools", ADMIN_ALLOWED_TOOLS.join(","),
+    "--permission-mode", "dontAsk",
+    "--model", "claude-opus-4-6",
+    "--max-turns", "20",
+  ];
+  if (resumeSessionId) {
+    args.push("--resume", resumeSessionId);
+  }
+  args.push(message);
+  const proc = spawn("claude", args, {
+    cwd: accountDir,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  // Pipe stderr to a log file. Never discard it — MCP warnings, first-run
+  // setup messages, and real errors all arrive here. Without draining it the
+  // 64 KB pipe buffer fills, the process deadlocks, and stdout stops flowing.
+  const stderrLog = agentLogStream("claude-agent-stderr");
+  proc.stderr?.pipe(stderrLog);
+  let buffer = "";
+  const readLines = async function* () {
+    for await (const chunk of proc.stdout) {
+      buffer += (chunk as Buffer).toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.trim()) yield line;
+      }
+    }
+    if (buffer.trim()) {
+      yield buffer;
+      buffer = "";
+    }
+  };
+  // Map tool call IDs to tool names so tool_result events carry the correct name
+  const toolIdToName = new Map<string, string>();
+  for await (const line of readLines()) {
+    let msg: Record<string, unknown>;
+    try { msg = JSON.parse(line); } catch { continue; }
+    if (msg.type === "system" && msg.subtype === "init") {
+      const agentSessionId = msg.session_id as string;
+      yield { type: "session_init", sessionId: agentSessionId };
+      if (sessionKey) storeAgentSessionId(sessionKey, agentSessionId);
+      continue;
+    }
+    if (msg.type === "assistant") {
+      const content = (msg.message as Record<string, unknown> | undefined)?.content as
+        Array<{ type: string; text?: string; thinking?: string; name?: string; input?: Record<string, unknown>; id?: string }> | undefined;
+      if (content) {
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            yield { type: "text", content: block.text };
+          } else if (block.type === "thinking" && block.thinking) {
+            yield { type: "thinking", content: block.thinking };
+          } else if (block.type === "tool_use" && block.name) {
+            if (block.id) toolIdToName.set(block.id, block.name);
+            yield { type: "tool_use", name: block.name, input: block.input ?? {} };
+          }
+        }
+      }
+      continue;
+    }
+    if (msg.type === "user") {
+      const content = (msg as Record<string, unknown>).content as
+        Array<{ type: string; tool_use_id?: string; content?: string; is_error?: boolean }> | undefined;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === "tool_result") {
+            const name = (block.tool_use_id && toolIdToName.get(block.tool_use_id)) || block.tool_use_id || "unknown";
+            yield {
+              type: "tool_result",
+              name,
+              output: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
+              error: block.is_error,
+            };
+          }
+        }
+      }
+      continue;
+    }
+    if (msg.type === "system") {
+      if (msg.subtype === "task_started") {
+        yield { type: "subagent_start", name: "subagent", task: String(msg.description ?? "") };
+      } else if (msg.subtype === "task_notification") {
+        yield { type: "subagent_end", name: "subagent", result: String(msg.message ?? "") };
+      }
+      continue;
+    }
+    if ("result" in msg) {
+      const usage = (msg as { usage?: { input_tokens?: number; output_tokens?: number } }).usage;
+      if (usage?.input_tokens !== undefined) {
+        yield { type: "usage", input_tokens: usage.input_tokens, output_tokens: usage.output_tokens ?? 0 };
+      }
+      yield { type: "done" };
+    }
+  }
+}
+// ---------------------------------------------------------------------------
+// Public agent: direct Anthropic API (no Claude Code)
+// ---------------------------------------------------------------------------
+async function* invokePublicAgent(
+  message: string,
+  systemPrompt: string,
+  accountId: string
+): AsyncGenerator<AgentStreamEvent> {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    yield { type: "text", content: "Public agent is not configured. ANTHROPIC_API_KEY is missing." };
+    yield { type: "done" };
+    return;
+  }
+  const memoryContext = await fetchMemoryContext(accountId, message);
+  const system = memoryContext
+    ? `${systemPrompt}\n\n<memory>\n${memoryContext}\n</memory>`
+    : systemPrompt;
+  const client = new Anthropic({ apiKey });
+  const stream = client.messages.stream({
+    model: "claude-haiku-4-5-20251001",
+    max_tokens: 1024,
+    system,
+    messages: [{ role: "user", content: message }],
+  });
+  for await (const event of stream) {
+    if (
+      event.type === "content_block_delta" &&
+      event.delta.type === "text_delta"
+    ) {
+      yield { type: "text", content: event.delta.text };
+    }
+  }
+  yield { type: "done" };
+}
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+interface AgentInvokeConfig {
+  type: "public" | "admin";
+  agentName?: string;
+}
+export async function* invokeAgent(
+  config: AgentInvokeConfig,
+  message: string,
+  sessionKey?: string
+): AsyncGenerator<AgentStreamEvent> {
+  const { type: agentType, agentName } = config;
+  const sessionAccountId = sessionKey ? getAccountIdForSession(sessionKey) : undefined;
+  const account = resolveAccount();
+  if (!account) {
+    yield { type: "text", content: "No account configured. Please complete onboarding first." };
+    yield { type: "done" };
+    return;
+  }
+  const accountId = sessionAccountId ?? account.accountId;
+  const resolvedAgentName = agentName ?? agentType;
+  const identity = readIdentity(account.accountDir, resolvedAgentName);
+  const defaultSystemPrompt = agentType === "public"
+    ? "You are a public assistant. Answer only from the memory context provided. Never use training data. British English. Be concise."
+    : "You are an admin agent. Full access. Professional, concise. British English. Be proactive — tell the user what needs doing and do it.";
+  const systemPrompt = identity ?? defaultSystemPrompt;
+  if (agentType === "public") {
+    yield* invokePublicAgent(message, systemPrompt, accountId);
+  } else {
+    yield* invokeAdminAgent(message, systemPrompt, account.accountDir, accountId, sessionKey);
+  }
+}
+export type AgentStreamEvent =
+  | { type: "session_init"; sessionId: string }
+  | { type: "text"; content: string }
+  | { type: "thinking"; content: string }
+  | { type: "tool_use"; name: string; input: Record<string, unknown> }
+  | { type: "tool_result"; name: string; output: string; error?: boolean }
+  | { type: "subagent_start"; name: string; task: string }
+  | { type: "subagent_end"; name: string; result: string }
+  | { type: "status"; message: string }
+  | { type: "usage"; input_tokens: number; output_tokens: number }
+  | { type: "done" };

package/payload/maxy/app/og/layout.tsx ADDED Viewed

@@ -0,0 +1,15 @@
+export default function OGLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <div
+      style={{
+        margin: 0,
+        padding: 0,
+        overflow: 'hidden',
+        backgroundColor: '#FAFAF8',
+        minHeight: '100vh',
+      }}
+    >
+      {children}
+    </div>
+  )
+}