@skillsgate/tui 0.1.14 → 0.2.0

package/package.json

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

package/src/components/help-overlay.tsx

@@ -29,6 +29,7 @@ const SHORTCUTS_RIGHT: ShortcutEntry[] = [
   { key: "", description: "" },
   { key: "-- Servers View --", description: "" },
   { key: "S", description: "Sync selected server" },
+  { key: "P", description: "push local skills to selected server" },
   { key: "a", description: "Add new server" },
   { key: "e", description: "Edit server" },
   { key: "t", description: "Test connection" },

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-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/local-skills.ts

@@ -0,0 +1,64 @@
+// packages/tui/src/db/local-skills.ts
+/**
+ * Pure async scanner for local canonical skills under ~/.agents/skills.
+ * Returns the minimal shape needed by the push orchestrator.
+ * Does NOT depend on React, the store, or the DB layer.
+ */
+import fs from "node:fs/promises"
+import path from "node:path"
+import os from "node:os"
+
+const home = os.homedir()
+export const CANONICAL_SKILLS_DIR = path.join(home, ".agents", "skills")
+
+export interface LocalCanonicalSkill {
+  folderName: string
+  canonicalPath: string
+  name: string
+}
+
+/**
+ * List all skill directories under ~/.agents/skills that contain a SKILL.md.
+ * Uses the folder name as both folderName and name (SKILL.md name field is
+ * parsed by the push orchestrator's hash step, which reads the file again).
+ */
+export async function listLocalCanonicalSkills(): Promise<LocalCanonicalSkill[]> {
+  const results: LocalCanonicalSkill[] = []
+  let names: string[]
+  try {
+    names = await fs.readdir(CANONICAL_SKILLS_DIR)
+  } catch {
+    return []
+  }
+
+  for (const name of names) {
+    const skillDir = path.join(CANONICAL_SKILLS_DIR, name)
+    let stat: Awaited<ReturnType<typeof fs.stat>>
+    try {
+      stat = await fs.stat(skillDir)
+    } catch {
+      continue // broken symlink or unreadable
+    }
+    if (!stat.isDirectory()) continue
+
+    let canonicalPath: string
+    try {
+      canonicalPath = await fs.realpath(skillDir)
+    } catch {
+      continue
+    }
+
+    const skillMdPath = path.join(canonicalPath, "SKILL.md")
+    try {
+      await fs.access(skillMdPath)
+    } catch {
+      continue // no SKILL.md
+    }
+    results.push({
+      folderName: name,
+      canonicalPath,
+      name,
+    })
+  }
+  return results
+}

package/src/db/push.ts

@@ -0,0 +1,220 @@
+// packages/tui/src/db/push.ts
+import crypto from "node:crypto"
+import path from "node:path"
+import { promises as fs } from "node:fs"
+
+import type { RemoteServer } from "./servers.js"
+import {
+  scanRemoteSkills,
+  uploadSkillDir,
+  deleteRemoteSkillDir,
+} from "./ssh.js"
+import { listLocalCanonicalSkills, CANONICAL_SKILLS_DIR } from "./local-skills.js"
+
+export interface PushPlanEntry {
+  folderName: string
+  name: string
+  localPath: string
+  remotePath: string
+  remoteDir: string
+  reason: "added" | "updated" | "deleted" | "unchanged"
+  localHash?: string
+  remoteHash?: string
+}
+
+export interface PushPreview {
+  toAdd: PushPlanEntry[]
+  toUpdate: PushPlanEntry[]
+  toDelete: PushPlanEntry[]
+  unchanged: PushPlanEntry[]
+  mirror: boolean
+}
+
+export interface PushResult {
+  added: number
+  updated: number
+  deleted: number
+  unchanged: number
+  errors: { folderName: string; message: string }[]
+}
+
+export interface PushOptions {
+  mirror: boolean
+}
+
+function sha256(s: string): string {
+  return crypto.createHash("sha256").update(s, "utf-8").digest("hex")
+}
+
+/**
+ * Resolve the remote skills base path to an absolute path relative to the server,
+ * dropping a trailing slash. We don't expand "~/" here -- that happens server-side
+ * via $HOME inside shellQuotePath.
+ */
+function normalizeRemoteBase(p: string): string {
+  return p.replace(/\/+$/, "")
+}
+
+/**
+ * Diff local canonical skills against the remote scan. Returns the plan.
+ * Does NOT execute anything.
+ */
+export async function planPush(
+  server: RemoteServer,
+  options: PushOptions,
+): Promise<PushPreview> {
+  // 1. List local canonical skills under ~/.agents/skills
+  const localCanonical = await listLocalCanonicalSkills()
+
+  // 2. Hash each local SKILL.md
+  const localByFolder = new Map<
+    string,
+    { folderName: string; name: string; localPath: string; hash: string }
+  >()
+  for (const s of localCanonical) {
+    const skillMdPath = path.join(s.canonicalPath, "SKILL.md")
+    let content: string
+    try {
+      content = await fs.readFile(skillMdPath, "utf-8")
+    } catch {
+      continue // skill dir without SKILL.md -- skip
+    }
+    localByFolder.set(s.folderName, {
+      folderName: s.folderName,
+      name: s.name,
+      localPath: s.canonicalPath,
+      hash: sha256(content),
+    })
+  }
+
+  // 3. Scan remote
+  const remote = await scanRemoteSkills(server)
+  const remoteBase = normalizeRemoteBase(server.skillsBasePath)
+
+  // Match remote skills to local folder names by remotePath suffix.
+  // remotePath looks like "<skillsBasePath>/<folderName>/SKILL.md".
+  // We strip the basePath prefix and the "/SKILL.md" suffix to recover folderName.
+  const remoteByFolder = new Map<string, { remotePath: string; hash: string }>()
+  for (const r of remote) {
+    const rp = r.remotePath
+    if (!rp.endsWith("/SKILL.md")) continue
+    // Remove the trailing "/SKILL.md"
+    const skillDir = rp.slice(0, -"/SKILL.md".length)
+    // Try to match by basename so we tolerate "~/.agents/skills" vs "$HOME/..." differences
+    const folderName = path.posix.basename(skillDir)
+    if (!folderName) continue
+    remoteByFolder.set(folderName, { remotePath: rp, hash: r.contentHash })
+  }
+
+  const toAdd: PushPlanEntry[] = []
+  const toUpdate: PushPlanEntry[] = []
+  const unchanged: PushPlanEntry[] = []
+  const toDelete: PushPlanEntry[] = []
+
+  for (const [folderName, local] of localByFolder) {
+    const remoteEntry = remoteByFolder.get(folderName)
+    const remoteDir = `${remoteBase}/${folderName}`
+    const remotePath = `${remoteDir}/SKILL.md`
+    if (!remoteEntry) {
+      toAdd.push({
+        folderName,
+        name: local.name,
+        localPath: local.localPath,
+        remotePath,
+        remoteDir,
+        reason: "added",
+        localHash: local.hash,
+      })
+    } else if (remoteEntry.hash !== local.hash) {
+      toUpdate.push({
+        folderName,
+        name: local.name,
+        localPath: local.localPath,
+        remotePath,
+        remoteDir,
+        reason: "updated",
+        localHash: local.hash,
+        remoteHash: remoteEntry.hash,
+      })
+    } else {
+      unchanged.push({
+        folderName,
+        name: local.name,
+        localPath: local.localPath,
+        remotePath,
+        remoteDir,
+        reason: "unchanged",
+        localHash: local.hash,
+        remoteHash: remoteEntry.hash,
+      })
+    }
+  }
+
+  if (options.mirror) {
+    for (const [folderName, remoteEntry] of remoteByFolder) {
+      if (localByFolder.has(folderName)) continue
+      const remoteDir = `${remoteBase}/${folderName}`
+      toDelete.push({
+        folderName,
+        name: folderName,
+        localPath: "",
+        remotePath: remoteEntry.remotePath,
+        remoteDir,
+        reason: "deleted",
+        remoteHash: remoteEntry.hash,
+      })
+    }
+  }
+
+  return { toAdd, toUpdate, toDelete, unchanged, mirror: options.mirror }
+}
+
+/**
+ * Apply a previously-computed plan. Errors per skill are collected, not thrown,
+ * so a single failure doesn't abort the entire push.
+ */
+export async function applyPush(
+  server: RemoteServer,
+  preview: PushPreview,
+): Promise<PushResult> {
+  const errors: { folderName: string; message: string }[] = []
+  const remoteBase = normalizeRemoteBase(server.skillsBasePath)
+
+  // Uploads (added + updated). Use uploadSkillDir which handles tar pipeline.
+  for (const entry of [...preview.toAdd, ...preview.toUpdate]) {
+    try {
+      await uploadSkillDir(server, CANONICAL_SKILLS_DIR, entry.folderName, remoteBase)
+    } catch (err) {
+      errors.push({
+        folderName: entry.folderName,
+        message: err instanceof Error ? err.message : String(err),
+      })
+    }
+  }
+
+  // Deletions (mirror only)
+  if (preview.mirror) {
+    for (const entry of preview.toDelete) {
+      try {
+        await deleteRemoteSkillDir(server, entry.remoteDir)
+      } catch (err) {
+        errors.push({
+          folderName: entry.folderName,
+          message: err instanceof Error ? err.message : String(err),
+        })
+      }
+    }
+  }
+
+  // Compute counts: subtract failures
+  const failedFolders = new Set(errors.map((e) => e.folderName))
+  return {
+    added: preview.toAdd.filter((e) => !failedFolders.has(e.folderName)).length,
+    updated: preview.toUpdate.filter((e) => !failedFolders.has(e.folderName)).length,
+    deleted: preview.mirror
+      ? preview.toDelete.filter((e) => !failedFolders.has(e.folderName)).length
+      : 0,
+    unchanged: preview.unchanged.length,
+    errors,
+  }
+}

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)
@@ -274,6 +299,89 @@ function parseDelimitedOutput(output: string): ScannedRemoteSkill[] {
   return skills
 }
 
+/**
+ * Upload an entire local skill directory to the remote server.
+ * Streams `tar -cf - -C <parentLocalDir> <folderName>` into
+ * `tar -xf - -C <remoteBaseDir>` over SSH.
+ *
+ * Both directories must already exist on the remote (caller ensures via mkdir -p).
+ */
+export async function uploadSkillDir(
+  server: RemoteServer,
+  parentLocalDir: string,
+  folderName: string,
+  remoteBaseDir: string,
+): Promise<void> {
+  // Ensure remote base dir exists first
+  const baseQuoted = shellQuotePath(remoteBaseDir)
+  const mkdirResult = await sshExec(server, `mkdir -p ${baseQuoted}`)
+  if (mkdirResult.exitCode !== 0) {
+    throw new Error(
+      mkdirResult.stderr.trim() || `mkdir -p failed for ${remoteBaseDir}`,
+    )
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    const tarLocal = spawn("tar", ["-cf", "-", "-C", parentLocalDir, folderName], {
+      stdio: ["ignore", "pipe", "pipe"],
+    })
+
+    const sshArgs = [...buildSshArgs(server), `tar -xf - -C ${baseQuoted}`]
+    const tarRemote = spawn("ssh", sshArgs, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 120_000,
+    })
+
+    let localStderr = ""
+    let remoteStderr = ""
+    tarLocal.stderr.on("data", (c: Buffer) => (localStderr += c.toString("utf-8")))
+    tarRemote.stderr.on("data", (c: Buffer) => (remoteStderr += c.toString("utf-8")))
+
+    tarLocal.stdout.pipe(tarRemote.stdin)
+
+    tarLocal.on("error", (err) => reject(err))
+    tarRemote.on("error", (err) => reject(err))
+
+    tarRemote.on("close", (code) => {
+      if ((code ?? 1) === 0) {
+        resolve()
+      } else {
+        reject(
+          new Error(
+            remoteStderr.trim() ||
+              localStderr.trim() ||
+              `tar pipeline exited with code ${code ?? 1}`,
+          ),
+        )
+      }
+    })
+  })
+}
+
+/**
+ * Delete a single skill directory on the remote.
+ * Used only by Mirror mode. Caller is responsible for confirming with the user.
+ */
+export async function deleteRemoteSkillDir(
+  server: RemoteServer,
+  remoteSkillDir: string,
+): Promise<void> {
+  const quoted = shellQuotePath(remoteSkillDir)
+  // Refuse to delete the entire skills base path or anything ending in '/'
+  if (
+    !remoteSkillDir ||
+    remoteSkillDir === "/" ||
+    remoteSkillDir === server.skillsBasePath ||
+    remoteSkillDir === server.skillsBasePath.replace(/\/+$/, "")
+  ) {
+    throw new Error(`Refusing to delete suspicious remote path: ${remoteSkillDir}`)
+  }
+  const result = await sshExec(server, `rm -rf ${quoted}`)
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || `rm -rf failed for ${remoteSkillDir}`)
+  }
+}
+
 // ---------- Sync Orchestrator ----------
 
 export interface SyncResult {
@@ -283,6 +391,7 @@ export interface SyncResult {
   unchanged: number
   total: number
   log: string[]
+  error?: string
 }
 
 export async function syncRemoteServer(
@@ -349,7 +458,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 +467,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