@skillsgate/tui 0.1.15 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillsgate/tui",
-  "version": "0.1.15",
+  "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/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

@@ -299,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 {

package/src/views/push-dialog.tsx

@@ -0,0 +1,251 @@
+// packages/tui/src/views/push-dialog.tsx
+import { useState } from "react"
+import { useKeyboard } from "@opentui/react"
+import { colors } from "../utils/colors.js"
+import type { RemoteServer } from "../db/servers.js"
+import { planPush, applyPush } from "../db/push.js"
+import type { PushPreview, PushResult } from "../db/push.js"
+
+interface PushDialogProps {
+  server: RemoteServer
+  onClose: (result?: PushResult) => void
+}
+
+type Stage = "choose" | "previewing" | "review" | "applying" | "done" | "error"
+
+/**
+ * TUI push dialog. State machine: choose -> previewing -> review -> applying -> done | error.
+ * Keybindings:
+ *   m      toggle Mirror mode (in choose)
+ *   Enter  advance (choose->preview, review->apply if changes exist)
+ *   Esc    cancel / go back
+ */
+export function PushDialog({ server, onClose }: PushDialogProps) {
+  const [mirror, setMirror] = useState(false)
+  const [stage, setStage] = useState<Stage>("choose")
+  const [preview, setPreview] = useState<PushPreview | null>(null)
+  const [result, setResult] = useState<PushResult | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  const totalChanges =
+    (preview?.toAdd.length ?? 0) +
+    (preview?.toUpdate.length ?? 0) +
+    (preview?.toDelete.length ?? 0)
+
+  useKeyboard((key) => {
+    if (stage === "previewing" || stage === "applying") return // no input while running
+
+    if (key.name === "escape") {
+      if (stage === "review") {
+        // Go back to choose
+        setStage("choose")
+        setPreview(null)
+        return
+      }
+      onClose()
+      return
+    }
+
+    if (stage === "choose") {
+      if (key.name === "m") {
+        setMirror((v) => !v)
+        return
+      }
+      if (key.name === "return") {
+        runPreview()
+        return
+      }
+    }
+
+    if (stage === "review") {
+      if (key.name === "return" && totalChanges > 0) {
+        runApply()
+        return
+      }
+    }
+
+    if (stage === "done" || stage === "error") {
+      if (key.name === "return" || key.name === "escape") {
+        onClose(result ?? undefined)
+        return
+      }
+    }
+  })
+
+  async function runPreview() {
+    setStage("previewing")
+    setError(null)
+    try {
+      const p = await planPush(server, { mirror })
+      setPreview(p)
+      setStage("review")
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err))
+      setStage("error")
+    }
+  }
+
+  async function runApply() {
+    if (!preview) return
+    setStage("applying")
+    setError(null)
+    try {
+      const r = await applyPush(server, preview)
+      setResult(r)
+      setStage("done")
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err))
+      setStage("error")
+    }
+  }
+
+  return (
+    <box
+      style={{
+        width: "100%",
+        height: "100%",
+        justifyContent: "center",
+        alignItems: "center",
+        backgroundColor: colors.bg,
+      }}
+    >
+      <box
+        style={{
+          width: 72,
+          border: true,
+          borderColor: colors.primary,
+          backgroundColor: "#1a1a2e",
+          paddingLeft: 2,
+          paddingRight: 2,
+          paddingTop: 1,
+          paddingBottom: 1,
+          flexDirection: "column",
+        }}
+        title={`Push to ${server.label}`}
+      >
+        {stage === "choose" && (
+          <>
+            <text fg={colors.primary}>
+              <strong>Push to {server.label}</strong>
+            </text>
+            <text>{" "}</text>
+            <text fg={mirror ? colors.textDim : colors.success}>
+              {mirror ? "  " : "> "}[Push] additive — adds/updates only, never deletes
+            </text>
+            <text fg={mirror ? colors.warning : colors.textDim}>
+              {mirror ? "> " : "  "}[Mirror] one-to-one — also deletes remote-only skills
+            </text>
+            <text>{" "}</text>
+            <text fg={colors.textDim}>
+              m=toggle mode  Enter=preview  Esc=cancel
+            </text>
+          </>
+        )}
+
+        {stage === "previewing" && (
+          <>
+            <text fg={colors.textDim}>Computing diff...</text>
+          </>
+        )}
+
+        {stage === "review" && preview && (
+          <>
+            <text fg={colors.primary}>
+              <strong>Preview</strong>
+              {preview.mirror ? (
+                <span fg={colors.warning}> (Mirror mode)</span>
+              ) : null}
+            </text>
+            <text>{" "}</text>
+            <text fg={colors.text}>
+              <span fg={colors.success}>{preview.toAdd.length} to add</span>
+              {"  "}
+              <span fg={colors.warning}>{preview.toUpdate.length} to update</span>
+              {preview.mirror ? (
+                <>
+                  {"  "}
+                  <span fg={colors.error}>{preview.toDelete.length} to delete</span>
+                </>
+              ) : null}
+              {"  "}
+              <span fg={colors.textDim}>{preview.unchanged.length} unchanged</span>
+            </text>
+            <text>{" "}</text>
+            {totalChanges === 0 ? (
+              <text fg={colors.textDim}>Nothing to push — remote already matches local.</text>
+            ) : (
+              <>
+                {preview.toAdd.map((e, i) => (
+                  <text key={`add-${i}`} fg={colors.success}>+ {e.folderName}</text>
+                ))}
+                {preview.toUpdate.map((e, i) => (
+                  <text key={`upd-${i}`} fg={colors.warning}>~ {e.folderName}</text>
+                ))}
+                {preview.toDelete.map((e, i) => (
+                  <text key={`del-${i}`} fg={colors.error}>- {e.folderName}</text>
+                ))}
+              </>
+            )}
+            {preview.mirror && preview.toDelete.length > 0 && (
+              <>
+                <text>{" "}</text>
+                <text fg={colors.error}>
+                  Mirror will delete {preview.toDelete.length} skill{preview.toDelete.length === 1 ? "" : "s"} from remote.
+                </text>
+              </>
+            )}
+            <text>{" "}</text>
+            <text fg={colors.textDim}>
+              {totalChanges > 0
+                ? preview.mirror && preview.toDelete.length > 0
+                  ? "Enter=confirm mirror (destructive)  Esc=back"
+                  : "Enter=apply  Esc=back"
+                : "Esc=close"}
+            </text>
+          </>
+        )}
+
+        {stage === "applying" && (
+          <text fg={colors.textDim}>Pushing to remote...</text>
+        )}
+
+        {stage === "done" && result && (
+          <>
+            <text fg={colors.success}><strong>Push complete</strong></text>
+            <text>{" "}</text>
+            <text fg={colors.text}>
+              <span fg={colors.success}>{result.added} added</span>
+              {"  "}
+              <span fg={colors.warning}>{result.updated} updated</span>
+              {"  "}
+              <span fg={result.deleted > 0 ? colors.error : colors.textDim}>{result.deleted} deleted</span>
+              {"  "}
+              <span fg={colors.textDim}>{result.unchanged} unchanged</span>
+            </text>
+            {result.errors.length > 0 && (
+              <>
+                <text>{" "}</text>
+                <text fg={colors.error}>Errors ({result.errors.length}):</text>
+                {result.errors.map((e, i) => (
+                  <text key={i} fg={colors.error}>  {e.folderName}: {e.message}</text>
+                ))}
+              </>
+            )}
+            <text>{" "}</text>
+            <text fg={colors.textDim}>Enter or Esc to close</text>
+          </>
+        )}
+
+        {stage === "error" && (
+          <>
+            <text fg={colors.error}><strong>Push failed</strong></text>
+            <text>{" "}</text>
+            <text fg={colors.error}>{error || "Unknown error"}</text>
+            <text>{" "}</text>
+            <text fg={colors.textDim}>Enter or Esc to close</text>
+          </>
+        )}
+      </box>
+    </box>
+  )
+}

package/src/views/servers.tsx

@@ -6,6 +6,7 @@ import { ConfirmDialog } from "../components/confirm-dialog.js"
 import { testConnection, syncRemoteServer } from "../db/ssh.js"
 import { colors } from "../utils/colors.js"
 import type { RemoteServer } from "../db/servers.js"
+import { PushDialog } from "./push-dialog.js"
 
 interface ServersViewProps {
   onServerCountChange: (count: number) => void
@@ -40,6 +41,7 @@ export function ServersView({ onServerCountChange }: ServersViewProps) {
   const [serverList, setServerList] = useState<RemoteServer[]>(() => servers.list())
   const [selectedIndex, setSelectedIndex] = useState(0)
   const [pendingAction, setPendingAction] = useState<PendingAction>(null)
+  const [pushTarget, setPushTarget] = useState<RemoteServer | null>(null)
   const [syncing, setSyncing] = useState(false)
   const [syncLog, setSyncLog] = useState<string[] | null>(null)
   const [testing, setTesting] = useState(false)
@@ -67,6 +69,7 @@ export function ServersView({ onServerCountChange }: ServersViewProps) {
     if (state.activeView !== "servers") return
     if (state.showHelp) return
     if (pendingAction) return
+    if (pushTarget) return
     if (syncing || testing) return
 
     // j/k or arrow keys
@@ -116,6 +119,12 @@ export function ServersView({ onServerCountChange }: ServersViewProps) {
       return
     }
 
+    // P = push to selected server
+    if (key.name === "P" && selectedServer) {
+      setPushTarget(selectedServer)
+      return
+    }
+
     // Enter = browse server's skills
     if (key.name === "return" && selectedServer) {
       const count = skillCounts.get(selectedServer.id) ?? 0
@@ -193,6 +202,19 @@ export function ServersView({ onServerCountChange }: ServersViewProps) {
     }
   }, [servers, skills, dispatch, refreshList])
 
+  // Push dialog
+  if (pushTarget) {
+    return (
+      <PushDialog
+        server={pushTarget}
+        onClose={() => {
+          setPushTarget(null)
+          refreshList()
+        }}
+      />
+    )
+  }
+
   // Confirm dialog for delete
   if (pendingAction?.type === "delete") {
     return (
@@ -327,7 +349,7 @@ export function ServersView({ onServerCountChange }: ServersViewProps) {
           {/* Bottom shortcut hints */}
           <box style={{ height: 1, paddingLeft: 1, backgroundColor: colors.bgAlt }}>
             <text fg={colors.textDim}>
-              S=sync  Enter=browse  a=add  e=edit  d=delete  t=test
+              S=sync  P=push  Enter=browse  a=add  e=edit  d=delete  t=test
             </text>
           </box>
         </box>
@@ -400,7 +422,7 @@ function ServerDetailPanel({ server, skillCount }: ServerDetailPanelProps) {
       ) : null}
 
       <text fg={colors.border}>---</text>
-      <text fg={colors.textDim}>S=sync  t=test  e=edit  d=delete  Enter=browse skills</text>
+      <text fg={colors.textDim}>S=sync  P=push  t=test  e=edit  d=delete  Enter=browse skills</text>
     </box>
   )
 }