maverick-ai-cli 1.0.0

package/src/lib/token.js

@@ -0,0 +1,104 @@
+import fs from "node:fs/promises";
+import chalk from "chalk";
+import path from "path";
+import os from "os";
+
+// Token file paths
+export const CONFIG_DIR = path.join(os.homedir(), ".better-auth");
+export const TOKEN_FILE = path.join(CONFIG_DIR, "token.json");
+
+/**
+ * Read the stored token data safely
+ */
+export async function getStoredToken() {
+  try {
+    const data = await fs.readFile(TOKEN_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Store a token with metadata
+ */
+export async function storeToken(token) {
+  try {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+
+    const tokenData = {
+      access_token: token.access_token,
+      refresh_token: token.refresh_token,
+      token_type: token.token_type || "Bearer",
+      scope: token.scope,
+      expires_at: token.expires_in
+        ? new Date(Date.now() + token.expires_in * 1000).toISOString()
+        : null,
+      created_at: new Date().toISOString(),
+    };
+
+    await fs.writeFile(
+      TOKEN_FILE,
+      JSON.stringify(tokenData, null, 2),
+      "utf-8"
+    );
+
+    return true;
+  } catch (err) {
+    console.error(chalk.red("Failed to store token:"), err.message);
+    return false;
+  }
+}
+
+/**
+ * Remove stored token
+ */
+export async function clearStoredToken() {
+  try {
+    await fs.rm(TOKEN_FILE, { force: true });
+    console.log(chalk.yellow("⚠ Token cleared"));
+    return true;
+  } catch (err) {
+    console.error(chalk.red("Failed to clear token:"), err.message);
+    return false;
+  }
+}
+
+/**
+ * Check if token is expired or about to expire (5 min window)
+ */
+export async function isTokenExpired() {
+  const token = await getStoredToken();
+
+  if (!token || !token.expires_at) {
+    return true;
+  }
+
+  const expiresAt = new Date(token.expires_at).getTime();
+  const now = Date.now();
+
+  // token is considered expired if less than 5 minutes remain
+  const FIVE_MINUTES = 5 * 60 * 1000;
+  return expiresAt - now < FIVE_MINUTES;
+}
+
+/**
+ * Require a valid token for authenticated commands
+ */
+export async function requireAuth() {
+  const token = await getStoredToken();
+
+  if (!token) {
+    console.log(chalk.red("You are not logged in."));
+    console.log(chalk.gray("Run: your-cli login\n"));
+    process.exit(1);
+  }
+
+  if (await isTokenExpired()) {
+    console.log(chalk.yellow("Your session has expired."));
+    console.log(chalk.gray("Run: your-cli login\n"));
+    process.exit(1);
+  }
+
+  return token;
+}

package/src/service/chat.service.js

@@ -0,0 +1,117 @@
+
+import prisma from "../lib/db.js"
+
+export class ChatService {
+
+    async createConversation(userId, mode = "chat", title = null) {
+        return prisma.conversation.create({
+            data: {
+                userId,
+                mode,
+                title: title || `New ${mode} conversation`
+            }
+        })
+    }
+
+    async getOrCreateConversation(userId, conversationId = null, mode = "chat") {
+        if (conversationId) {
+            const conversation = await prisma.conversation.findFirst({
+                where: {
+                    id: conversationId,
+                    userId
+                },
+                include: {
+                    messages: {
+                        orderBy: {
+                            createdAt: "asc"
+                        }
+                    }
+                }
+            });
+
+            if (conversation) {
+                return conversation
+            }
+        }
+
+        return await this.createConversation(userId, mode)
+    }
+
+    async createMessage(conversationId, role, content) {
+        const contentStr = typeof content === "string"
+            ? content
+            : JSON.stringify(content);
+
+        return await prisma.message.create({
+            data: {
+                conversationId,
+                role,
+                content: contentStr
+            }
+        })
+    }
+
+
+    async getMessages(conversationId) {
+        const messages = await prisma.message.findMany({
+            where: { conversationId },
+            orderBy: { createdAt: "asc" }
+        })
+
+        return messages.map((msg) => ({
+            ...msg,
+            content: this.parseContent(msg.content)
+        }))
+    }
+
+
+
+    async getUserConversation(userId) {
+        return await prisma.conversation.findMany({
+            where: { userId },
+            orderBy: { updatedAt: "desc" },
+            include: {
+                messages: {
+                    take: 1,
+                    orderBy: { createdAt: "desc" }
+                }
+            }
+        })
+    }
+
+
+    async deleteConversation(conversationId, userId) {
+        return await prisma.conversation.deleteMany({
+            where: {
+                id: conversationId,
+                userId,
+            },
+        })
+    }
+
+
+    async updateConversationTitle(conversationId, title) {
+        return await prisma.conversation.update({
+            where: { id: conversationId },
+            data: { title },
+        })
+    }
+
+    parseContent(content) {
+        try {
+            return JSON.parse(content)
+        } catch (error) {
+            return content
+        }
+    }
+
+
+    formatMessagesForAI(messages) {
+        return messages.map((msg) => ({
+            role: msg.role,
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        }))
+    }
+
+
+}