@skillsgate/tui 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillsgate/tui",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "type": "module",
   "bin": {
     "skillsgate-tui": "bin/skillsgate-tui"

package/src/data/api-client.ts

@@ -1,4 +1,3 @@
-const SKILLSGATE_API_BASE = process.env.SKILLSGATE_SEARCH_API_URL ?? "https://api.skillsgate.ai"
 const SKILLS_SH_BASE = "https://skills.sh"
 const GITHUB_API_BASE = "https://api.github.com"
 const GITHUB_RAW_BASE = "https://raw.githubusercontent.com"
@@ -115,6 +114,3 @@ export async function fetchSkillContent(
   return null
 }
 
-// ---------- SkillsGate API (auth, favorites, private skills) ----------
-
-export { SKILLSGATE_API_BASE }

package/src/data/use-installed-skills.ts

@@ -1,4 +1,4 @@
-import { useEffect } from "react"
+import { useEffect, useRef } from "react"
 import fs from "node:fs/promises"
 import path from "node:path"
 import os from "node:os"
@@ -8,6 +8,7 @@ import { useDb } from "../db/context.js"
 import { agents } from "../../../cli/src/core/agents.js"
 import { readSkillLock } from "../../../cli/src/core/skill-lock.js"
 import { SKILL_MD } from "../../../cli/src/constants.js"
+import { loadCachedSkills, saveCachedSkills, type CachedSkill } from "../db/skills-cache.js"
 import type { EnrichedSkill } from "../store/types.js"
 import type { AgentType, SkillLockFile } from "../../../cli/src/types.js"
 
@@ -92,111 +93,121 @@ async function listSupportingFiles(skillDir: string): Promise<Array<{ relativePa
   return files.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
 }
 
+/**
+ * Convert cached skill rows into lightweight EnrichedSkill objects
+ * suitable for rendering the list immediately on startup.
+ */
+function cachedToEnriched(cached: CachedSkill[], lock: SkillLockFile): EnrichedSkill[] {
+  return cached.map((c) => ({
+    name: c.name,
+    description: c.description,
+    filePath: path.join(c.canonicalPath, SKILL_MD),
+    canonicalPath: c.canonicalPath,
+    agents: c.agents,
+    scope: c.scope,
+    projectName: c.scope === "project" ? getProjectNameForPath(c.canonicalPath) : null,
+    hasSupportingFiles: false,
+    supportingFiles: [],
+    metadata: {} as Record<string, unknown>,
+    lock: lock.skills[c.folderName],
+  }))
+}
+
+/**
+ * Convert EnrichedSkill objects from a full scan into CachedSkill rows
+ * for persistence in the SQLite database.
+ */
+function enrichedToCached(skills: EnrichedSkill[]): CachedSkill[] {
+  const now = new Date().toISOString()
+  return skills.map((s) => ({
+    canonicalPath: s.canonicalPath,
+    folderName: path.basename(s.canonicalPath),
+    name: s.name,
+    description: s.description,
+    agents: s.agents,
+    agentShortCodes: [],
+    scope: s.scope,
+    source: s.lock?.source ?? null,
+    sourceType: s.lock?.sourceType ?? null,
+    fileModTime: now,
+    scannedAt: now,
+  }))
+}
+
+/**
+ * Dispatch agent counts derived from the given skills array.
+ */
+function dispatchAgentCounts(
+  skills: EnrichedSkill[],
+  dispatch: ReturnType<typeof useDispatch>,
+): void {
+  const agentCounts = new Map<AgentType, number>()
+  for (const skill of skills) {
+    for (const agentName of skill.agents) {
+      agentCounts.set(agentName, (agentCounts.get(agentName) ?? 0) + 1)
+    }
+  }
+  dispatch({ type: "UPDATE_AGENT_COUNTS", counts: Object.fromEntries(agentCounts) })
+}
+
 /**
  * Scans all detected agent globalSkillsDir paths for SKILL.md files,
  * parses them with gray-matter, enriches with lock file data, and
  * populates the store.
+ *
+ * On first mount, cached results are served instantly while a background
+ * rescan runs. Subsequent tab switches reuse the cache. Press `r` to
+ * force a full rescan.
  */
 export function useInstalledSkills() {
   const dispatch = useDispatch()
   const { installedLoading } = useStore()
-  const { settings } = useDb()
+  const { db, settings } = useDb()
+  const hasLoadedCache = useRef(false)
 
   useEffect(() => {
-    // Only scan when installedLoading is true (initial mount or refresh triggered)
+    // Only act when installedLoading is true (initial mount or refresh triggered)
     if (!installedLoading) return
 
     let cancelled = false
 
-    async function scan() {
-      dispatch({ type: "SET_INSTALLED_LOADING", loading: true })
-
-      try {
-        const lock = await readSkillLock()
-        // Map: skillName -> EnrichedSkill (deduplicating across agents)
-        const skillMap = new Map<string, EnrichedSkill>()
-
-        // Scan each agent's global skills directory
-        for (const agent of Object.values(agents)) {
-          const skillsDir = agent.globalSkillsDir
-          try {
-            const entries = await fs.readdir(skillsDir, { withFileTypes: true })
-            for (const entry of entries) {
-              // Include both real directories and symlinks (skills are often symlinked)
-              if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
-
-              const skillDirPath = path.join(skillsDir, entry.name)
-              const canonicalPath = await fs.realpath(skillDirPath).catch(() => skillDirPath)
-              const skillMdPath = path.join(skillDirPath, SKILL_MD)
-              try {
-                const raw = await fs.readFile(skillMdPath, "utf-8")
-                const { data: frontmatter } = matter(raw)
-                const skillName = entry.name
-                const canonicalPath = await fs.realpath(skillDirPath).catch(() => skillDirPath)
-                const scope = getScopeForPath(canonicalPath)
-                const supportingFiles = await listSupportingFiles(canonicalPath)
-
-                const existing = skillMap.get(canonicalPath)
-                if (existing) {
-                  // Skill already seen from another agent - add this agent
-                  if (!existing.agents.includes(agent.name)) {
-                    existing.agents.push(agent.name)
-                  }
-                } else {
-                  skillMap.set(canonicalPath, {
-                    name: skillName,
-                    description:
-                      (frontmatter.description as string) ??
-                      extractFirstLine(raw),
-                    filePath: skillMdPath,
-                    canonicalPath,
-                    agents: [agent.name],
-                    scope,
-                    projectName:
-                      scope === "project" ? getProjectNameForPath(canonicalPath) : null,
-                    hasSupportingFiles: supportingFiles.length > 0,
-                    supportingFiles,
-                    metadata: frontmatter as Record<string, unknown>,
-                    lock: lock.skills[skillName],
-                  })
-                }
-              } catch {
-                // SKILL.md not found or unreadable in this directory - skip
-              }
-            }
-          } catch {
-            // Agent skills directory doesn't exist - skip
-          }
-        }
-
-        const customScanPaths = settings.get<string[]>("scan.customPaths", [])
-        for (const customPath of customScanPaths) {
-          const resolvedRoot = path.resolve(customPath.replace(/^~(?=$|\/|\\)/, home))
-          const collected = await collectCustomSkills(resolvedRoot, lock)
-          for (const skill of collected) {
-            if (!skillMap.has(skill.canonicalPath)) {
-              skillMap.set(skill.canonicalPath, skill)
+    async function loadFromCacheAndScan() {
+      const isInitialLoad = !hasLoadedCache.current
+
+      // On initial load, try serving from cache first for instant startup
+      if (isInitialLoad) {
+        try {
+          const cached = loadCachedSkills(db)
+          if (cached.length > 0) {
+            const lock = await readSkillLock()
+            const skills = cachedToEnriched(cached, lock)
+            if (!cancelled) {
+              dispatch({ type: "SET_INSTALLED_SKILLS", skills })
+              dispatchAgentCounts(skills, dispatch)
+              hasLoadedCache.current = true
             }
           }
+        } catch {
+          // Cache read failed; fall through to full scan
         }
+      }
 
+      // Run full filesystem scan (in background after cache, or blocking on refresh)
+      try {
+        const scannedSkills = await fullScan(settings)
         if (cancelled) return
 
-        const skills = Array.from(skillMap.values()).sort((a, b) =>
-          a.name.localeCompare(b.name)
-        )
-
-        dispatch({ type: "SET_INSTALLED_SKILLS", skills })
-
-        // Update agent skill counts (without removing agents that have 0 skills)
-        const agentCounts = new Map<AgentType, number>()
-        for (const skill of skills) {
-          for (const agentName of skill.agents) {
-            agentCounts.set(agentName, (agentCounts.get(agentName) ?? 0) + 1)
-          }
+        // Persist to cache
+        try {
+          saveCachedSkills(db, enrichedToCached(scannedSkills))
+        } catch {
+          // Cache write failed; non-critical
         }
 
-        dispatch({ type: "UPDATE_AGENT_COUNTS", counts: Object.fromEntries(agentCounts) })
+        hasLoadedCache.current = true
+
+        dispatch({ type: "SET_INSTALLED_SKILLS", skills: scannedSkills })
+        dispatchAgentCounts(scannedSkills, dispatch)
       } catch {
         if (!cancelled) {
           dispatch({ type: "SET_INSTALLED_SKILLS", skills: [] })
@@ -204,11 +215,88 @@ export function useInstalledSkills() {
       }
     }
 
-    scan()
+    loadFromCacheAndScan()
     return () => { cancelled = true }
   }, [installedLoading])
 }
 
+/**
+ * Performs a full filesystem scan across all agent directories and custom paths.
+ */
+async function fullScan(
+  settings: ReturnType<typeof useDb>["settings"],
+): Promise<EnrichedSkill[]> {
+  const lock = await readSkillLock()
+  const skillMap = new Map<string, EnrichedSkill>()
+
+  // Scan each agent's global skills directory
+  for (const agent of Object.values(agents)) {
+    const skillsDir = agent.globalSkillsDir
+    try {
+      const entries = await fs.readdir(skillsDir, { withFileTypes: true })
+      for (const entry of entries) {
+        // Include both real directories and symlinks (skills are often symlinked)
+        if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
+
+        const skillDirPath = path.join(skillsDir, entry.name)
+        const skillMdPath = path.join(skillDirPath, SKILL_MD)
+        try {
+          const raw = await fs.readFile(skillMdPath, "utf-8")
+          const { data: frontmatter } = matter(raw)
+          const skillName = entry.name
+          const canonicalPath = await fs.realpath(skillDirPath).catch(() => skillDirPath)
+          const scope = getScopeForPath(canonicalPath)
+          const supportingFiles = await listSupportingFiles(canonicalPath)
+
+          const existing = skillMap.get(canonicalPath)
+          if (existing) {
+            // Skill already seen from another agent - add this agent
+            if (!existing.agents.includes(agent.name)) {
+              existing.agents.push(agent.name)
+            }
+          } else {
+            skillMap.set(canonicalPath, {
+              name: skillName,
+              description:
+                (frontmatter.description as string) ??
+                extractFirstLine(raw),
+              filePath: skillMdPath,
+              canonicalPath,
+              agents: [agent.name],
+              scope,
+              projectName:
+                scope === "project" ? getProjectNameForPath(canonicalPath) : null,
+              hasSupportingFiles: supportingFiles.length > 0,
+              supportingFiles,
+              metadata: frontmatter as Record<string, unknown>,
+              lock: lock.skills[skillName],
+            })
+          }
+        } catch {
+          // SKILL.md not found or unreadable in this directory - skip
+        }
+      }
+    } catch {
+      // Agent skills directory doesn't exist - skip
+    }
+  }
+
+  const customScanPaths = settings.get<string[]>("scan.customPaths", [])
+  for (const customPath of customScanPaths) {
+    const resolvedRoot = path.resolve(customPath.replace(/^~(?=$|\/|\\)/, home))
+    const collected = await collectCustomSkills(resolvedRoot, lock)
+    for (const skill of collected) {
+      if (!skillMap.has(skill.canonicalPath)) {
+        skillMap.set(skill.canonicalPath, skill)
+      }
+    }
+  }
+
+  return Array.from(skillMap.values()).sort((a, b) =>
+    a.name.localeCompare(b.name)
+  )
+}
+
 async function collectCustomSkills(
   rootPath: string,
   lock: SkillLockFile,

package/src/data/use-skill-actions.ts

@@ -20,8 +20,6 @@ import {
   removeSkillFromLock,
 } from "../../../cli/src/core/skill-lock.js"
 import { agents, detectInstalledAgents } from "../../../cli/src/core/agents.js"
-import { downloadSkill } from "../../../cli/src/core/skillsgate-client.js"
-import { getToken } from "../../../cli/src/utils/auth-store.js"
 import type { Skill, AgentConfig } from "../../../cli/src/types.js"
 
 interface UseSkillActionsResult {
@@ -43,7 +41,6 @@ export function useSkillActions(): UseSkillActionsResult {
   /**
    * Install a skill from its source.
    * For public skills (with a source in owner/repo format), runs `npx skills add`.
-   * For private skills, uses the existing download flow.
    */
   const installSkill = useCallback(async (skill: EnrichedSkill) => {
     dispatch({
@@ -73,7 +70,6 @@ export function useSkillActions(): UseSkillActionsResult {
         return
       }
 
-      // Private skills: use the existing download flow
       const installedAgents = await detectInstalledAgents()
       if (installedAgents.length === 0) {
         dispatch({
@@ -98,15 +94,8 @@ export function useSkillActions(): UseSkillActionsResult {
         preferredNames.includes(agent.name),
       )
 
-      let tmpDir: string
-      if (source.type === "skillsgate") {
-        // Download from private API
-        const token = await getToken()
-        tmpDir = await downloadSkill(source.username!, source.slug!, token)
-      } else {
-        // Local path -- use directly
-        tmpDir = source.localPath!
-      }
+      // Local path source uses resolved path directly
+      const tmpDir = source.localPath!
 
       try {
         // Discover skills in the downloaded directory
@@ -277,7 +266,6 @@ export function useSkillActions(): UseSkillActionsResult {
   /**
    * Update a skill by re-fetching from its source.
    * For GitHub skills: checks tree SHA for changes before re-installing.
-   * For SkillsGate skills: always re-downloads.
    */
   const updateSkill = useCallback(async (skill: EnrichedSkill) => {
     if (!skill.lock) {

package/src/db/migrations.ts

@@ -50,6 +50,26 @@ const MIGRATIONS: Migration[] = [
       INSERT OR IGNORE INTO schema_version VALUES (1);
     `,
   },
+  {
+    version: 2,
+    up: `
+      CREATE TABLE IF NOT EXISTS cached_skills (
+        canonical_path TEXT PRIMARY KEY,
+        folder_name TEXT NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        agents TEXT NOT NULL DEFAULT '[]',
+        agent_short_codes TEXT NOT NULL DEFAULT '[]',
+        scope TEXT NOT NULL DEFAULT 'global',
+        source TEXT,
+        source_type TEXT,
+        file_mod_time TEXT NOT NULL,
+        scanned_at TEXT NOT NULL
+      );
+
+      INSERT OR IGNORE INTO schema_version VALUES (2);
+    `,
+  },
 ]
 
 function getCurrentVersion(db: Database): number {

package/src/db/skills-cache.ts

@@ -0,0 +1,89 @@
+import type { Database } from "bun:sqlite"
+import type { AgentType, SourceType } from "../../../cli/src/types.js"
+
+export interface CachedSkill {
+  canonicalPath: string
+  folderName: string
+  name: string
+  description: string
+  agents: AgentType[]
+  agentShortCodes: string[]
+  scope: "global" | "project" | "custom"
+  source: string | null
+  sourceType: SourceType | null
+  fileModTime: string
+  scannedAt: string
+}
+
+interface CachedSkillRow {
+  canonical_path: string
+  folder_name: string
+  name: string
+  description: string
+  agents: string
+  agent_short_codes: string
+  scope: string
+  source: string | null
+  source_type: string | null
+  file_mod_time: string
+  scanned_at: string
+}
+
+function rowToSkill(row: CachedSkillRow): CachedSkill {
+  return {
+    canonicalPath: row.canonical_path,
+    folderName: row.folder_name,
+    name: row.name,
+    description: row.description,
+    agents: JSON.parse(row.agents) as AgentType[],
+    agentShortCodes: JSON.parse(row.agent_short_codes) as string[],
+    scope: row.scope as CachedSkill["scope"],
+    source: row.source,
+    sourceType: row.source_type as SourceType | null,
+    fileModTime: row.file_mod_time,
+    scannedAt: row.scanned_at,
+  }
+}
+
+export function loadCachedSkills(db: Database): CachedSkill[] {
+  const rows = db
+    .query("SELECT * FROM cached_skills ORDER BY name ASC")
+    .all() as CachedSkillRow[]
+  return rows.map(rowToSkill)
+}
+
+export function saveCachedSkills(db: Database, skills: CachedSkill[]): void {
+  const insert = db.query(
+    `INSERT OR REPLACE INTO cached_skills
+       (canonical_path, folder_name, name, description, agents, agent_short_codes, scope, source, source_type, file_mod_time, scanned_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  )
+
+  db.exec("BEGIN TRANSACTION")
+  try {
+    db.exec("DELETE FROM cached_skills")
+    for (const skill of skills) {
+      insert.run(
+        skill.canonicalPath,
+        skill.folderName,
+        skill.name,
+        skill.description,
+        JSON.stringify(skill.agents),
+        JSON.stringify(skill.agentShortCodes),
+        skill.scope,
+        skill.source,
+        skill.sourceType,
+        skill.fileModTime,
+        skill.scannedAt,
+      )
+    }
+    db.exec("COMMIT")
+  } catch (err) {
+    db.exec("ROLLBACK")
+    throw err
+  }
+}
+
+export function clearSkillsCache(db: Database): void {
+  db.exec("DELETE FROM cached_skills")
+}

package/src/db/ssh.ts

@@ -198,34 +198,59 @@ function sha256(content: string): string {
   return crypto.createHash("sha256").update(content).digest("hex")
 }
 
+/**
+ * Detect "directory does not exist" errors from `find` stderr.
+ */
+function isMissingDirError(stderr: string): boolean {
+  return /no such file or directory/i.test(stderr)
+}
+
 export async function scanRemoteSkills(
   server: RemoteServer
 ): Promise<ScannedRemoteSkill[]> {
   const basePath = shellQuotePath(server.skillsBasePath)
 
-  // Round trip 1: Find all SKILL.md files
+  // Round trip 1: Find all SKILL.md files. Capture stderr (do NOT redirect to
+  // /dev/null) so we can distinguish "directory doesn't exist" from real errors.
   const findResult = await sshExec(
     server,
-    `find ${basePath} -name 'SKILL.md' -type f 2>/dev/null`
+    `find ${basePath} -name 'SKILL.md' -type f`
   )
-  if (findResult.exitCode !== 0 && findResult.stdout.trim() === "") {
-    throw new Error(`Find failed: ${findResult.stderr.trim()}`)
-  }
 
-  const paths = findResult.stdout.trim().split("\n").filter(Boolean)
+  const paths = findResult.stdout
+    .split("\n")
+    .map((p) => p.trim())
+    .filter(Boolean)
+
+  if (findResult.exitCode !== 0 && paths.length === 0) {
+    const stderr = findResult.stderr.trim()
+    // Missing skills directory on a fresh remote is a normal state.
+    if (isMissingDirError(stderr)) return []
+    throw new Error(
+      stderr || `find exited with code ${findResult.exitCode} on ${server.skillsBasePath}`
+    )
+  }
   if (paths.length === 0) return []
 
-  // Round trip 2: Batch read all files in a single SSH call
-  const catCommands = paths
+  // Round trip 2: Batch read all files in a single SSH call.
+  // Single-quote escaping handles arbitrary characters; only reject paths with
+  // chars that would break our delimiter parser.
+  const safePaths = paths.filter((p) => !/[\x00\n\r]/.test(p))
+  if (safePaths.length === 0) return []
+
+  const catCommands = safePaths
     .map((p) => {
       const escaped = `'${p.replace(/'/g, "'\\''")}'`
-      return `echo '${DELIMITER_PREFIX}${p}${DELIMITER_SUFFIX}' && cat ${escaped}`
+      const delimPath = p.replace(/'/g, "'\\''")
+      return `printf '%s\\n' '${DELIMITER_PREFIX}${delimPath}${DELIMITER_SUFFIX}' && cat ${escaped}`
     })
     .join(" && ")
 
   const catResult = await sshExec(server, catCommands)
-  if (catResult.exitCode !== 0) {
-    throw new Error(`Batch read failed: ${catResult.stderr.trim()}`)
+  if (catResult.exitCode !== 0 && catResult.stdout.trim() === "") {
+    throw new Error(
+      catResult.stderr.trim() || `cat exited with code ${catResult.exitCode}`
+    )
   }
 
   return parseDelimitedOutput(catResult.stdout)
@@ -283,6 +308,7 @@ export interface SyncResult {
   unchanged: number
   total: number
   log: string[]
+  error?: string
 }
 
 export async function syncRemoteServer(
@@ -349,7 +375,7 @@ export async function syncRemoteServer(
     }
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err)
-    log.push(`SSH connection failed: ${errorMsg}`)
+    log.push(`Sync failed: ${errorMsg}`)
     serverStore.updateSyncStatus(server.id, errorMsg)
     return {
       added: 0,
@@ -358,6 +384,7 @@ export async function syncRemoteServer(
       unchanged: 0,
       total: 0,
       log,
+      error: errorMsg,
     }
   }
 }

package/src/store/reducers.ts

@@ -5,7 +5,6 @@ const FOCUS_ORDER: FocusedPane[] = ["agents", "search", "list"]
 export const initialState: AppState = {
   activeView: "home",
   previousView: null,
-  auth: null,
   detectedAgents: [],
   selectedAgentFilter: "all",
   installedSkills: [],
@@ -14,8 +13,6 @@ export const initialState: AppState = {
   searchQuery: "",
   searchResults: [],
   searchLoading: false,
-  favorites: [],
-  favoritesLoading: false,
   selectedSkill: null,
   selectedServerId: null,
   showHelp: false,
@@ -40,9 +37,6 @@ export function appReducer(state: AppState, action: Action): AppState {
         previousView: null,
       }
 
-    case "SET_AUTH":
-      return { ...state, auth: action.auth }
-
     case "SET_DETECTED_AGENTS":
       return { ...state, detectedAgents: action.agents }
 
@@ -76,12 +70,6 @@ export function appReducer(state: AppState, action: Action): AppState {
     case "SET_SEARCH_LOADING":
       return { ...state, searchLoading: action.loading }
 
-    case "SET_FAVORITES":
-      return { ...state, favorites: action.favorites, favoritesLoading: false }
-
-    case "SET_FAVORITES_LOADING":
-      return { ...state, favoritesLoading: action.loading }
-
     case "SELECT_SKILL":
       return {
         ...state,

package/src/store/types.ts

@@ -5,14 +5,12 @@ import type { AgentType, SkillLockEntry, SourceType } from "../../../cli/src/typ
 export type ViewName =
   | "home"
   | "discover"
-  | "favorites"
   | "servers"
   | "server-skills"
   | "add-server"
   | "edit-server"
   | "settings"
   | "detail"
-  | "login"
 
 // ---------- Enriched Skill ----------
 
@@ -44,13 +42,6 @@ export interface DetectedAgent {
   skillCount: number
 }
 
-// ---------- Auth ----------
-
-export interface AuthState {
-  token: string
-  user: { id: string; name: string; email: string }
-}
-
 // ---------- Notification ----------
 
 export interface Notification {
@@ -68,9 +59,6 @@ export interface AppState {
   activeView: ViewName
   previousView: ViewName | null
 
-  // Auth
-  auth: AuthState | null
-
   // Agent detection
   detectedAgents: DetectedAgent[]
 
@@ -85,10 +73,6 @@ export interface AppState {
   searchResults: unknown[]
   searchLoading: boolean
 
-  // Favorites
-  favorites: unknown[]
-  favoritesLoading: boolean
-
   // Detail
   selectedSkill: EnrichedSkill | null
 
@@ -108,7 +92,6 @@ export interface AppState {
 export type Action =
   | { type: "NAVIGATE"; view: ViewName }
   | { type: "GO_BACK" }
-  | { type: "SET_AUTH"; auth: AuthState | null }
   | { type: "SET_DETECTED_AGENTS"; agents: DetectedAgent[] }
   | { type: "UPDATE_AGENT_COUNTS"; counts: Record<string, number> }
   | { type: "SET_AGENT_FILTER"; filter: string }
@@ -118,8 +101,6 @@ export type Action =
   | { type: "SET_SEARCH_QUERY"; query: string }
   | { type: "SET_SEARCH_RESULTS"; results: unknown[] }
   | { type: "SET_SEARCH_LOADING"; loading: boolean }
-  | { type: "SET_FAVORITES"; favorites: unknown[] }
-  | { type: "SET_FAVORITES_LOADING"; loading: boolean }
   | { type: "SELECT_SKILL"; skill: EnrichedSkill }
   | { type: "PREVIEW_SKILL"; skill: EnrichedSkill }
   | { type: "CLEAR_SKILL" }

package/src/utils/colors.ts

@@ -25,6 +25,8 @@ export const agentBadges: Record<string, { label: string; color: string }> = {
   cursor:           { label: "Cu", color: "#5599FF" }, // blue
   windsurf:         { label: "W",  color: "#00CED1" }, // cyan
   "codex-cli":      { label: "Cx", color: "#FF4444" }, // red
+  "droid-cli":      { label: "Dr", color: "#22D3EE" }, // cyan
+  "ob-1":          { label: "OB", color: "#12B3DF" }, // openblock cyan
   opencode:         { label: "O",  color: "#2ECCAA" }, // teal
   zed:              { label: "Z",  color: "#FFFF00" }, // yellow
   "github-copilot": { label: "Gh", color: "#8B5CF6" }, // purple

package/src/views/servers.tsx

@@ -169,18 +169,21 @@ export function ServersView({ onServerCountChange }: ServersViewProps) {
     setSyncing(false)
     refreshList()
 
-    if (result.total > 0 || result.removed > 0) {
+    if (result.error) {
       dispatch({
         type: "SHOW_NOTIFICATION",
         notification: {
-          type: "success",
-          message: `Synced ${server.label}: ${result.added} new, ${result.updated} updated, ${result.removed} removed`,
+          type: "error",
+          message: `Sync failed for ${server.label}: ${result.error}`,
         },
       })
-    } else if (result.log.some((l) => l.includes("failed"))) {
+    } else if (result.total > 0 || result.removed > 0) {
       dispatch({
         type: "SHOW_NOTIFICATION",
-        notification: { type: "error", message: `Sync failed for ${server.label}` },
+        notification: {
+          type: "success",
+          message: `Synced ${server.label}: ${result.added} new, ${result.updated} updated, ${result.removed} removed`,
+        },
       })
     } else {
       dispatch({

package/src/data/use-auth.ts

@@ -1,136 +0,0 @@
-import { useEffect, useCallback } from "react"
-import { useStore, useDispatch } from "../store/context.js"
-import { useDb } from "../db/context.js"
-
-const API_BASE_URL = process.env.SKILLSGATE_API_URL ?? "https://skillsgate.ai"
-
-// SQLite settings keys for auth
-const AUTH_TOKEN_KEY = "auth.token"
-const AUTH_USER_KEY = "auth.user"
-
-interface AuthUser {
-  id: string
-  name: string
-  email: string
-  image?: string
-}
-
-interface ExchangeResponse {
-  access_token: string
-  user: AuthUser
-}
-
-/**
- * Auth hook using the shared SQLite database.
- * Both TUI and Electron read/write auth to the same DB at ~/.skillsgate/skillsgate.db
- * No keyring dependency -- works in both Bun and Node.
- */
-export function useAuth() {
-  const state = useStore()
-  const dispatch = useDispatch()
-  const { settings } = useDb()
-
-  // On mount, load auth from SQLite
-  useEffect(() => {
-    let cancelled = false
-
-    try {
-      const token = settings.get<string | null>(AUTH_TOKEN_KEY, null)
-      const user = settings.get<AuthUser | null>(AUTH_USER_KEY, null)
-
-      if (token && user) {
-        dispatch({
-          type: "SET_AUTH",
-          auth: { token, user },
-        })
-      } else {
-        // Try legacy file-based auth as fallback
-        loadLegacyAuth().then((legacy) => {
-          if (cancelled) return
-          if (legacy) {
-            settings.set(AUTH_TOKEN_KEY, legacy.token)
-            settings.set(AUTH_USER_KEY, legacy.user)
-            dispatch({
-              type: "SET_AUTH",
-              auth: { token: legacy.token, user: legacy.user },
-            })
-          } else {
-            dispatch({ type: "SET_AUTH", auth: null })
-          }
-        }).catch(() => {
-          if (!cancelled) dispatch({ type: "SET_AUTH", auth: null })
-        })
-      }
-    } catch {
-      dispatch({ type: "SET_AUTH", auth: null })
-    }
-
-    return () => { cancelled = true }
-  }, [])
-
-  const login = useCallback(async (code: string): Promise<string | null> => {
-    try {
-      const res = await fetch(`${API_BASE_URL}/api/auth/device/exchange`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ code }),
-      })
-
-      if (res.ok) {
-        const result = (await res.json()) as ExchangeResponse
-
-        // Save to SQLite (shared with Electron)
-        settings.set(AUTH_TOKEN_KEY, result.access_token)
-        settings.set(AUTH_USER_KEY, result.user)
-
-        dispatch({
-          type: "SET_AUTH",
-          auth: { token: result.access_token, user: result.user },
-        })
-        return null
-      }
-
-      const data = (await res.json().catch(() => ({}))) as { error?: string }
-
-      if (data?.error === "rate_limited") {
-        return "Too many attempts. Please wait a minute and try again."
-      } else if (data?.error === "invalid_code") {
-        return "Invalid code. Please check and try again."
-      } else if (data?.error === "expired") {
-        return "Code has expired. Get a new one from the browser."
-      }
-      return "Something went wrong. Please try again."
-    } catch {
-      return "Network error. Please check your connection and try again."
-    }
-  }, [dispatch, settings])
-
-  const logout = useCallback(async () => {
-    settings.set(AUTH_TOKEN_KEY, null)
-    settings.set(AUTH_USER_KEY, null)
-    dispatch({ type: "SET_AUTH", auth: null })
-  }, [dispatch, settings])
-
-  return {
-    auth: state.auth,
-    login,
-    logout,
-  }
-}
-
-/**
- * Try to load auth from the legacy CLI file (~/.skillsgate/auth.json + keyring).
- * Used as a one-time migration to SQLite.
- */
-async function loadLegacyAuth(): Promise<{ token: string; user: AuthUser } | null> {
-  try {
-    const { loadAuth } = await import("../../../cli/src/utils/auth-store.js")
-    const stored = await loadAuth()
-    if (stored?.token && stored?.user) {
-      return { token: stored.token, user: stored.user }
-    }
-  } catch {
-    // CLI auth-store not available or keyring failed
-  }
-  return null
-}

package/src/data/use-favorites.ts

@@ -1,161 +0,0 @@
-import { useState, useEffect, useCallback } from "react"
-import { useStore, useDispatch } from "../store/context.js"
-import { SKILLSGATE_API_BASE } from "./api-client.js"
-
-/**
- * Shape returned by the favorites API endpoint.
- */
-export interface FavoriteSkill {
-  id: string
-  name: string
-  description: string
-  summary?: string
-  categories: string[]
-  capabilities?: string[]
-  keywords?: string[]
-  githubUrl?: string
-  githubStars?: number | null
-  installCommand?: string | null
-  slug?: string
-  favoriteId?: string
-}
-
-const API_BASE = SKILLSGATE_API_BASE
-
-interface UseFavoritesResult {
-  favorites: FavoriteSkill[]
-  loading: boolean
-  error: string | null
-  toggle: (skillId: string) => Promise<void>
-  refresh: () => void
-}
-
-/**
- * Hook that manages the user's favorited skills.
- * Requires authentication -- returns empty list if not logged in.
- */
-export function useFavorites(): UseFavoritesResult {
-  const state = useStore()
-  const dispatch = useDispatch()
-  const [favorites, setFavorites] = useState<FavoriteSkill[]>([])
-  const [loading, setLoading] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-  const [refreshToken, setRefreshToken] = useState(0)
-
-  const token = state.auth?.token
-
-  // Fetch favorites when authenticated
-  useEffect(() => {
-    if (!token) {
-      setFavorites([])
-      setLoading(false)
-      return
-    }
-
-    let cancelled = false
-    setLoading(true)
-    setError(null)
-
-    async function fetchFavorites() {
-      try {
-        const res = await fetch(`${API_BASE}/api/favorites`, {
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${token}`,
-          },
-        })
-
-        if (!res.ok) {
-          throw new Error(`Failed to fetch favorites (HTTP ${res.status})`)
-        }
-
-        const data = (await res.json()) as { favorites: FavoriteSkill[] }
-        if (!cancelled) {
-          const items = data.favorites ?? []
-          setFavorites(items)
-          dispatch({ type: "SET_FAVORITES", favorites: items })
-        }
-      } catch (err) {
-        if (!cancelled) {
-          const msg = err instanceof Error ? err.message : String(err)
-          setError(msg)
-          setFavorites([])
-          dispatch({ type: "SET_FAVORITES", favorites: [] })
-        }
-      } finally {
-        if (!cancelled) {
-          setLoading(false)
-        }
-      }
-    }
-
-    fetchFavorites()
-    return () => { cancelled = true }
-  }, [token, refreshToken])
-
-  /**
-   * Toggle a skill's favorite status.
-   * If already favorited, removes it. Otherwise, adds it.
-   */
-  const toggle = useCallback(async (skillId: string) => {
-    if (!token) return
-
-    const isFavorited = favorites.some((f) => f.id === skillId)
-
-    try {
-      if (isFavorited) {
-        // Remove favorite
-        const res = await fetch(`${API_BASE}/api/favorites/${skillId}`, {
-          method: "DELETE",
-          headers: {
-            Authorization: `Bearer ${token}`,
-          },
-        })
-        if (!res.ok) {
-          throw new Error(`Failed to remove favorite (HTTP ${res.status})`)
-        }
-
-        // Optimistic update: remove from local list
-        setFavorites((prev) => {
-          const updated = prev.filter((f) => f.id !== skillId)
-          dispatch({ type: "SET_FAVORITES", favorites: updated })
-          return updated
-        })
-      } else {
-        // Add favorite
-        const res = await fetch(`${API_BASE}/api/favorites`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${token}`,
-          },
-          body: JSON.stringify({ skillId }),
-        })
-        if (!res.ok) {
-          throw new Error(`Failed to add favorite (HTTP ${res.status})`)
-        }
-
-        // Refresh the full list to get the complete skill data
-        setRefreshToken((t) => t + 1)
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err)
-      dispatch({
-        type: "SHOW_NOTIFICATION",
-        notification: { type: "error", message: msg },
-      })
-    }
-  }, [token, favorites, dispatch])
-
-  const refresh = useCallback(() => {
-    setRefreshToken((t) => t + 1)
-  }, [])
-
-  return {
-    favorites,
-    loading,
-    error,
-    toggle,
-    refresh,
-  }
-}

package/src/views/favorites.tsx

@@ -1,19 +0,0 @@
-import { colors } from "../utils/colors.js"
-
-/**
- * Favorites view: Coming soon placeholder.
- * Favorites require authentication which is not yet available in the public TUI.
- */
-export function FavoritesView() {
-  return (
-    <box style={{ flexDirection: "column", padding: 2 }}>
-      <text fg={colors.primary}>
-        <strong>Favorites</strong>
-      </text>
-      <text>{" "}</text>
-      <text fg={colors.text}>
-        Coming soon. Favorites will be available once accounts are launched.
-      </text>
-    </box>
-  )
-}

package/src/views/login.tsx

@@ -1,202 +0,0 @@
-import { useState, useCallback } from "react"
-import { useKeyboard } from "@opentui/react"
-import { useStore, useDispatch } from "../store/context.js"
-import { useAuth } from "../data/use-auth.js"
-import { API_BASE_URL } from "../../../cli/src/constants.js"
-import { colors } from "../utils/colors.js"
-
-type LoginStep = "prompt" | "code" | "exchanging"
-
-/**
- * Login view implementing the device code flow:
- * 1. Show instructions with the auth URL
- * 2. Prompt to open browser (y/n)
- * 3. Show input for device code (XXXX-XXXX)
- * 4. Exchange code for token, save auth, navigate back
- */
-export function LoginView() {
-  const state = useStore()
-  const dispatch = useDispatch()
-  const { auth, login, logout } = useAuth()
-
-  const [step, setStep] = useState<LoginStep>("prompt")
-  const [error, setError] = useState<string | null>(null)
-
-  const authUrl = `${API_BASE_URL}/cli/auth`
-
-  function openBrowser() {
-    try {
-      const { exec } = require("node:child_process")
-      const cmd = process.platform === "darwin" ? "open" : "xdg-open"
-      exec(`${cmd} "${authUrl}"`)
-      dispatch({
-        type: "SHOW_NOTIFICATION",
-        notification: { type: "info", message: "Opening browser..." },
-      })
-    } catch {
-      // Best effort
-    }
-  }
-
-  // Handle keyboard input
-  useKeyboard((key) => {
-    if (state.activeView !== "login") return
-    if (state.showHelp) return
-
-    // Esc to go back at any step
-    if (key.name === "escape") {
-      dispatch({ type: "GO_BACK" })
-      return
-    }
-
-    if (step === "prompt") {
-      // "r" to re-login (clear old auth, open browser, go to code step)
-      if (key.name === "r") {
-        logout()
-        openBrowser()
-        setStep("code")
-        return
-      }
-
-      // "o" to logout only (no re-login)
-      if (key.name === "o") {
-        logout()
-        dispatch({
-          type: "SHOW_NOTIFICATION",
-          notification: { type: "success", message: "Signed out" },
-        })
-        dispatch({ type: "GO_BACK" })
-        return
-      }
-
-      // "y" to open browser and proceed to code input
-      if (key.name === "y") {
-        openBrowser()
-        setStep("code")
-        return
-      }
-
-      // "n" to skip browser, go straight to code input
-      if (key.name === "n") {
-        setStep("code")
-        return
-      }
-    }
-  })
-
-  const handleCodeSubmit = useCallback(async (value: string) => {
-    const code = value.trim()
-    if (!code) return
-
-    setStep("exchanging")
-    setError(null)
-
-    const errMsg = await login(code)
-
-    if (errMsg) {
-      setError(errMsg)
-      setStep("code") // Let user retry
-    } else {
-      // Success - navigate back
-      dispatch({
-        type: "SHOW_NOTIFICATION",
-        notification: { type: "success", message: "Logged in successfully!" },
-      })
-      dispatch({ type: "GO_BACK" })
-    }
-  }, [login, dispatch])
-
-  // Already logged in -- offer re-login or logout
-  if (auth && step === "prompt") {
-    return (
-      <box style={{ flexDirection: "column", padding: 2 }}>
-        <text fg={colors.success}>
-          Logged in as <strong>{auth.user.name}</strong> ({auth.user.email})
-        </text>
-        <text>{" "}</text>
-        <text fg={colors.text}>
-          If AI search isn't working, your session may have expired.
-        </text>
-        <text>{" "}</text>
-        <text fg={colors.primary}>r</text>
-        <text fg={colors.text}>  Re-login with a fresh token</text>
-        <text fg={colors.primary}>o</text>
-        <text fg={colors.text}>  Sign out</text>
-        <text fg={colors.textDim}>Esc</text>
-        <text fg={colors.text}>  Go back</text>
-      </box>
-    )
-  }
-
-  return (
-    <box style={{ flexDirection: "column", padding: 2 }}>
-      {/* Title */}
-      <text fg={colors.primary}>
-        <strong>Sign in to SkillsGate</strong>
-      </text>
-      <text>{" "}</text>
-
-      {/* Instructions */}
-      <text fg={colors.text}>
-        Visit the following URL in your browser to get a login code:
-      </text>
-      <text>{" "}</text>
-      <text fg={colors.primary}>
-        {authUrl}
-      </text>
-      <text>{" "}</text>
-
-      {step === "prompt" && (
-        <>
-          <text fg={colors.text}>
-            Open browser? <span fg={colors.textDim}>(y/n)</span>
-          </text>
-        </>
-      )}
-
-      {step === "code" && (
-        <>
-          <text fg={colors.text}>
-            Paste the code from the browser:
-          </text>
-          <text>{" "}</text>
-          <box
-            style={{
-              height: 3,
-              width: 40,
-              border: true,
-              borderColor: colors.primary,
-              paddingLeft: 1,
-              paddingRight: 1,
-            }}
-            title="Code"
-          >
-            <input
-              placeholder="XXXX-XXXX"
-              focused={state.activeView === "login" && step === "code" && !state.showHelp}
-              onSubmit={handleCodeSubmit as any}
-            />
-          </box>
-          <text>{" "}</text>
-          <text fg={colors.textDim}>
-            Press Enter to submit, Esc to cancel
-          </text>
-        </>
-      )}
-
-      {step === "exchanging" && (
-        <text fg={colors.primary}>
-          Verifying code...
-        </text>
-      )}
-
-      {/* Error message */}
-      {error && (
-        <>
-          <text>{" "}</text>
-          <text fg={colors.error}>{error}</text>
-        </>
-      )}
-    </box>
-  )
-}