assistme 0.3.0 → 0.3.2

package/src/credentials/local-store.ts

@@ -0,0 +1,89 @@
+import Database, { type Database as DatabaseType } from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const DEFAULT_DB_DIR = join(homedir(), ".config", "assistme");
+const DEFAULT_DB_NAME = "local.db";
+
+/**
+ * Singleton SQLite-backed local store.
+ *
+ * Provides a shared database for all local-only data:
+ * credentials, cached tokens, user preferences, etc.
+ *
+ * - Single file: ~/.config/assistme/local.db
+ * - WAL mode for concurrent read performance
+ * - Auto-creates tables on first access
+ * - Directory permissions: 0o700, file inherits from SQLite
+ */
+export class LocalStore {
+  private db: DatabaseType;
+  readonly dbPath: string;
+
+  constructor(dbPath?: string) {
+    const dir = dbPath ? dbPath : DEFAULT_DB_DIR;
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+
+    this.dbPath = dbPath
+      ? join(dbPath, DEFAULT_DB_NAME)
+      : join(DEFAULT_DB_DIR, DEFAULT_DB_NAME);
+
+    this.db = new Database(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+
+    this.migrate();
+  }
+
+  /** Run schema migrations. Idempotent — safe to call on every startup. */
+  private migrate(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS credentials (
+        id            TEXT PRIMARY KEY,
+        name          TEXT NOT NULL UNIQUE,
+        type          TEXT NOT NULL DEFAULT 'secret',
+        skill_name    TEXT,
+        tags          TEXT NOT NULL DEFAULT '[]',
+        encrypted_data TEXT NOT NULL,
+        created_at    TEXT NOT NULL,
+        updated_at    TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_credentials_name ON credentials(name);
+      CREATE INDEX IF NOT EXISTS idx_credentials_skill ON credentials(skill_name);
+      CREATE INDEX IF NOT EXISTS idx_credentials_type ON credentials(type);
+    `);
+  }
+
+  /** Get the raw database handle for direct queries. */
+  getDb(): DatabaseType {
+    return this.db;
+  }
+
+  /** Close the database connection. */
+  close(): void {
+    this.db.close();
+  }
+}
+
+// ── Singleton ────────────────────────────────────────────────────────
+
+let _instance: LocalStore | null = null;
+
+export function getLocalStore(dbPath?: string): LocalStore {
+  if (!_instance) {
+    _instance = new LocalStore(dbPath);
+  }
+  return _instance;
+}
+
+/** Reset singleton (for tests). */
+export function resetLocalStore(): void {
+  if (_instance) {
+    _instance.close();
+    _instance = null;
+  }
+}

package/src/db/action.ts

@@ -0,0 +1,19 @@
+import { callMcpHandler } from "./api-client.js";
+
+export async function setActionRequest(
+  messageId: string,
+  actionData: Record<string, unknown>
+): Promise<void> {
+  await callMcpHandler("action.set_request", {
+    message_id: messageId,
+    action_data: actionData,
+  });
+}
+
+export async function pollActionResponse(
+  messageId: string
+): Promise<Record<string, unknown> | null> {
+  return callMcpHandler<Record<string, unknown> | null>("action.poll_response", {
+    message_id: messageId,
+  });
+}

package/src/db/api-client.ts

@@ -1,36 +1,7 @@
 import { getConfig } from "../utils/config.js";
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { getRawToken } from "./auth-store.js";
 
-// ── Auth Store (shared with supabase.ts) ────────────────────────────
-
-const AUTH_DIR = join(homedir(), ".config", "assistme");
-const AUTH_FILE = join(AUTH_DIR, "auth.json");
-
-function readAuthStore(): Record<string, string> {
-  try {
-    if (existsSync(AUTH_FILE)) {
-      return JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
-    }
-  } catch {
-    // Corrupted file — start fresh
-  }
-  return {};
-}
-
-/**
- * Get the raw MCP token from the local auth store.
- * Throws if not authenticated.
- */
-export function getRawToken(): string {
-  const store = readAuthStore();
-  const token = store["mcp_token"];
-  if (!token || !token.startsWith("am_")) {
-    throw new Error("Not authenticated. Run `assistme login`.");
-  }
-  return token;
-}
+export { getRawToken };
 
 /**
  * Call the mcp-handler edge function.
@@ -42,7 +13,7 @@ export function getRawToken(): string {
 export async function callMcpHandler<T = unknown>(
   action: string,
   params: Record<string, unknown> = {},
-  overrideToken?: string,
+  overrideToken?: string
 ): Promise<T> {
   const config = getConfig();
   const token = overrideToken || getRawToken();

package/src/db/auth-store.ts

@@ -0,0 +1,41 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const AUTH_DIR = join(homedir(), ".config", "assistme");
+const AUTH_FILE = join(AUTH_DIR, "auth.json");
+
+export function ensureAuthDir(): void {
+  if (!existsSync(AUTH_DIR)) {
+    mkdirSync(AUTH_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+export function readAuthStore(): Record<string, string> {
+  try {
+    if (existsSync(AUTH_FILE)) {
+      return JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+    }
+  } catch {
+    // Corrupted file — start fresh
+  }
+  return {};
+}
+
+export function writeAuthStore(data: Record<string, string>): void {
+  ensureAuthDir();
+  writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+/**
+ * Get the raw MCP token from the local auth store.
+ * Throws if not authenticated.
+ */
+export function getRawToken(): string {
+  const store = readAuthStore();
+  const token = store["mcp_token"];
+  if (!token || !token.startsWith("am_")) {
+    throw new Error("Not authenticated. Run `assistme login`.");
+  }
+  return token;
+}

package/src/db/auth.ts

@@ -0,0 +1,38 @@
+import { readAuthStore, writeAuthStore } from "./auth-store.js";
+import { callMcpHandler } from "./api-client.js";
+
+/**
+ * Login using an am_ MCP token.
+ * Validates against DB via edge function, stores locally.
+ */
+export async function loginWithToken(mcpToken: string): Promise<string> {
+  if (!mcpToken.startsWith("am_")) {
+    throw new Error("Invalid token format. Use an am_ token from the web page.");
+  }
+
+  const result = await callMcpHandler<{ user_id: string; email: string | null }>(
+    "auth.validate_token",
+    {},
+    mcpToken
+  );
+
+  // Persist token
+  const store = readAuthStore();
+  store["mcp_token"] = mcpToken;
+  writeAuthStore(store);
+
+  return result.user_id;
+}
+
+export async function getCurrentUserId(): Promise<string> {
+  const result = await callMcpHandler<{ user_id: string }>("auth.validate_token");
+  return result.user_id;
+}
+
+export async function logout(): Promise<void> {
+  try {
+    writeAuthStore({});
+  } catch {
+    // ignore
+  }
+}

package/src/db/conversation.ts

@@ -0,0 +1,39 @@
+import { callMcpHandler } from "./api-client.js";
+import { log } from "../utils/logger.js";
+import type { HistoryEntry } from "./types.js";
+
+export async function getOrCreateCliConversation(): Promise<string> {
+  const data = await callMcpHandler<string>("conversation.get_or_create");
+  return data;
+}
+
+/**
+ * Fetch completed messages from a conversation to build history context.
+ * Returns messages in chronological order (oldest first).
+ */
+export async function getConversationHistory(
+  conversationId: string,
+  excludeMessageId: string,
+  limit: number = 20
+): Promise<HistoryEntry[]> {
+  try {
+    const rows = await callMcpHandler<Array<Record<string, unknown>>>("conversation.get_history", {
+      conversation_id: conversationId,
+      exclude_message_id: excludeMessageId,
+      limit,
+    });
+
+    return (rows || [])
+      .reverse() // chronological order (oldest first)
+      .map((row) => {
+        const prompt = ((row.metadata as Record<string, unknown>)?.prompt as string) || "";
+        const content = (row.content as string) || "";
+        const response = row.status === "failed" ? `[Task failed] ${content}` : content;
+        return { prompt, response };
+      })
+      .filter((entry) => entry.prompt && entry.response);
+  } catch (err) {
+    log.debug(`Failed to fetch conversation history: ${err instanceof Error ? err.message : err}`);
+    return [];
+  }
+}

package/src/db/event.ts

@@ -0,0 +1,52 @@
+import { callMcpHandler } from "./api-client.js";
+import { log } from "../utils/logger.js";
+import type { EventType } from "./types.js";
+
+/**
+ * Per-task event emitter. Each task gets its own sequence counter
+ * to avoid cross-task sequence number collisions.
+ */
+export class TaskEventEmitter {
+  private sequence = 0;
+
+  constructor(private messageId: string) {}
+
+  async emit(eventType: EventType, eventData: Record<string, unknown>): Promise<void> {
+    this.sequence++;
+    try {
+      await callMcpHandler("event.emit", {
+        message_id: this.messageId,
+        event_type: eventType,
+        event_data: eventData,
+        seq: this.sequence,
+      });
+    } catch (err) {
+      log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+}
+
+// Legacy global API — kept for backward compatibility during migration
+let eventSequence = 0;
+
+export function resetEventSequence(): void {
+  eventSequence = 0;
+}
+
+export async function emitEvent(
+  messageId: string,
+  eventType: EventType,
+  eventData: Record<string, unknown>
+): Promise<void> {
+  eventSequence++;
+  try {
+    await callMcpHandler("event.emit", {
+      message_id: messageId,
+      event_type: eventType,
+      event_data: eventData,
+      seq: eventSequence,
+    });
+  } catch (err) {
+    log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
+  }
+}

package/src/db/job-poll.ts

@@ -0,0 +1,18 @@
+import { callMcpHandler } from "./api-client.js";
+import { log } from "../utils/logger.js";
+import type { PendingJobRun } from "./types.js";
+
+/**
+ * Atomically claim one pending job run.
+ * Uses FOR UPDATE SKIP LOCKED — concurrent CLIs will never grab the same run.
+ * Returns null if no pending job run exists.
+ */
+export async function pollAndClaimJobRun(): Promise<PendingJobRun | null> {
+  try {
+    const data = await callMcpHandler<PendingJobRun | null>("job.claim_pending_run");
+    return data;
+  } catch (err) {
+    log.debug(`Job run poll failed: ${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+}

package/src/db/session.ts

@@ -0,0 +1,60 @@
+import { callMcpHandler } from "./api-client.js";
+import { log } from "../utils/logger.js";
+import type { AgentSession } from "./types.js";
+
+export async function createSession(
+  sessionName: string,
+  workspacePath: string,
+  version: string
+): Promise<AgentSession> {
+  const { getConfig } = await import("../utils/config.js");
+  const data = await callMcpHandler<AgentSession>("session.create", {
+    session_name: sessionName,
+    workspace_path: workspacePath,
+    version,
+    model: getConfig().model || null,
+  });
+  return data;
+}
+
+export async function updateHeartbeat(sessionId: string): Promise<void> {
+  try {
+    await callMcpHandler("session.heartbeat", { session_id: sessionId });
+  } catch (err) {
+    log.warn(`Heartbeat update failed: ${err instanceof Error ? err.message : err}`);
+  }
+}
+
+export async function endSession(sessionId: string): Promise<void> {
+  try {
+    await callMcpHandler("session.end", { session_id: sessionId });
+  } catch (err) {
+    log.error(`Failed to end session: ${err instanceof Error ? err.message : err}`);
+  }
+}
+
+export async function setSessionBusy(sessionId: string, busy: boolean): Promise<void> {
+  await callMcpHandler("session.set_busy", {
+    session_id: sessionId,
+    busy,
+  });
+}
+
+export async function cleanupStaleSessions(
+  currentSessionId: string,
+  thresholdMs = 120_000
+): Promise<number> {
+  try {
+    const result = await callMcpHandler<{ cleaned: number }>("session.cleanup_stale", {
+      current_session_id: currentSessionId,
+      threshold_ms: thresholdMs,
+    });
+    return result.cleaned;
+  } catch {
+    return 0;
+  }
+}
+
+export async function getActiveSessions(limit = 5): Promise<AgentSession[]> {
+  return callMcpHandler<AgentSession[]>("session.get_active", { limit });
+}