airaknit 1.1.2-rc.9

package/src/server/skill-discovery.test.ts

@@ -0,0 +1,201 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { scanSkillDirs, SkillCache } from "./skill-discovery"
+
+const tempDirs: string[] = []
+
+afterEach(async () => {
+  await Promise.all(
+    tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true }))
+  )
+})
+
+async function makeTempDir(prefix = "tinkaria-skill-discovery-") {
+  const dir = await mkdtemp(join(tmpdir(), prefix))
+  tempDirs.push(dir)
+  return dir
+}
+
+async function createSkillDir(parent: string, name: string): Promise<void> {
+  const skillDir = join(parent, name)
+  await mkdir(skillDir, { recursive: true })
+  await writeFile(join(skillDir, `${name}.md`), `---\nname: ${name}\n---\nSkill content`)
+}
+
+describe("scanSkillDirs", () => {
+  test("returns skill names from user-level skills dir", async () => {
+    const homeDir = await makeTempDir()
+    const projectDir = await makeTempDir()
+    const skillsDir = join(homeDir, ".claude", "skills")
+    await mkdir(skillsDir, { recursive: true })
+    await createSkillDir(skillsDir, "commit")
+    await createSkillDir(skillsDir, "review-pr")
+
+    const skills = await scanSkillDirs(projectDir, homeDir)
+    expect(skills).toContain("commit")
+    expect(skills).toContain("review-pr")
+    expect(skills).toHaveLength(2)
+  })
+
+  test("returns skill names from project-level skills dir", async () => {
+    const homeDir = await makeTempDir()
+    const projectDir = await makeTempDir()
+    const skillsDir = join(projectDir, ".claude", "skills")
+    await mkdir(skillsDir, { recursive: true })
+    await createSkillDir(skillsDir, "c3")
+    await createSkillDir(skillsDir, "frontend-design")
+
+    const skills = await scanSkillDirs(projectDir, homeDir)
+    expect(skills).toContain("c3")
+    expect(skills).toContain("frontend-design")
+    expect(skills).toHaveLength(2)
+  })
+
+  test("merges user and project skills, deduplicates", async () => {
+    const homeDir = await makeTempDir()
+    const projectDir = await makeTempDir()
+
+    const userSkills = join(homeDir, ".claude", "skills")
+    await mkdir(userSkills, { recursive: true })
+    await createSkillDir(userSkills, "commit")
+    await createSkillDir(userSkills, "shared-skill")
+
+    const projSkills = join(projectDir, ".claude", "skills")
+    await mkdir(projSkills, { recursive: true })
+    await createSkillDir(projSkills, "c3")
+    await createSkillDir(projSkills, "shared-skill")
+
+    const skills = await scanSkillDirs(projectDir, homeDir)
+    expect(skills).toContain("commit")
+    expect(skills).toContain("c3")
+    expect(skills).toContain("shared-skill")
+    expect(skills).toHaveLength(3)
+  })
+
+  test("returns empty array when no skills dirs exist", async () => {
+    const homeDir = await makeTempDir()
+    const projectDir = await makeTempDir()
+
+    const skills = await scanSkillDirs(projectDir, homeDir)
+    expect(skills).toEqual([])
+  })
+
+  test("ignores plain files in skills directory", async () => {
+    const homeDir = await makeTempDir()
+    const projectDir = await makeTempDir()
+    const skillsDir = join(homeDir, ".claude", "skills")
+    await mkdir(skillsDir, { recursive: true })
+    await createSkillDir(skillsDir, "real-skill")
+    await writeFile(join(skillsDir, "not-a-skill.md"), "just a file")
+
+    const skills = await scanSkillDirs(projectDir, homeDir)
+    expect(skills).toEqual(["real-skill"])
+  })
+
+  test("returns sorted skill names for deterministic output", async () => {
+    const homeDir = await makeTempDir()
+    const projectDir = await makeTempDir()
+    const skillsDir = join(homeDir, ".claude", "skills")
+    await mkdir(skillsDir, { recursive: true })
+    await createSkillDir(skillsDir, "zebra")
+    await createSkillDir(skillsDir, "alpha")
+    await createSkillDir(skillsDir, "middle")
+
+    const skills = await scanSkillDirs(projectDir, homeDir)
+    expect(skills).toEqual(["alpha", "middle", "zebra"])
+  })
+})
+
+describe("SkillCache", () => {
+  test("returns discovered skills on first call", async () => {
+    const homeDir = await makeTempDir()
+    const projectDir = await makeTempDir()
+    const skillsDir = join(projectDir, ".claude", "skills")
+    await mkdir(skillsDir, { recursive: true })
+    await createSkillDir(skillsDir, "c3")
+
+    const cache = new SkillCache({ ttlMs: 5000, homeDir })
+    const skills = await cache.get(projectDir)
+    expect(skills).toEqual(["c3"])
+  })
+
+  test("returns cached result within TTL", async () => {
+    const homeDir = await makeTempDir()
+    const projectDir = await makeTempDir()
+    const skillsDir = join(projectDir, ".claude", "skills")
+    await mkdir(skillsDir, { recursive: true })
+    await createSkillDir(skillsDir, "c3")
+
+    const cache = new SkillCache({ ttlMs: 5000, homeDir })
+    const first = await cache.get(projectDir)
+
+    // Add another skill after first scan
+    await createSkillDir(skillsDir, "new-skill")
+    const second = await cache.get(projectDir)
+
+    // Should return cached (stale) result
+    expect(second).toEqual(first)
+    expect(second).not.toContain("new-skill")
+  })
+
+  test("re-scans after TTL expires", async () => {
+    const homeDir = await makeTempDir()
+    const projectDir = await makeTempDir()
+    const skillsDir = join(projectDir, ".claude", "skills")
+    await mkdir(skillsDir, { recursive: true })
+    await createSkillDir(skillsDir, "c3")
+
+    const cache = new SkillCache({ ttlMs: 50, homeDir })
+    const first = await cache.get(projectDir)
+    expect(first).toEqual(["c3"])
+
+    await createSkillDir(skillsDir, "new-skill")
+    await new Promise((r) => setTimeout(r, 60))
+
+    const second = await cache.get(projectDir)
+    expect(second).toContain("c3")
+    expect(second).toContain("new-skill")
+  })
+
+  test("invalidate clears specific project cache", async () => {
+    const homeDir = await makeTempDir()
+    const projectDir = await makeTempDir()
+    const skillsDir = join(projectDir, ".claude", "skills")
+    await mkdir(skillsDir, { recursive: true })
+    await createSkillDir(skillsDir, "c3")
+
+    const cache = new SkillCache({ ttlMs: 60_000, homeDir })
+    await cache.get(projectDir)
+
+    await createSkillDir(skillsDir, "new-skill")
+    cache.invalidate(projectDir)
+
+    const refreshed = await cache.get(projectDir)
+    expect(refreshed).toContain("new-skill")
+  })
+
+  test("invalidate without args clears all caches", async () => {
+    const homeDir = await makeTempDir()
+    const proj1 = await makeTempDir()
+    const proj2 = await makeTempDir()
+
+    for (const dir of [proj1, proj2]) {
+      const skillsDir = join(dir, ".claude", "skills")
+      await mkdir(skillsDir, { recursive: true })
+      await createSkillDir(skillsDir, "skill-a")
+    }
+
+    const cache = new SkillCache({ ttlMs: 60_000, homeDir })
+    await cache.get(proj1)
+    await cache.get(proj2)
+
+    cache.invalidate()
+
+    // Add new skills after invalidation
+    await createSkillDir(join(proj1, ".claude", "skills"), "added")
+    const refreshed = await cache.get(proj1)
+    expect(refreshed).toContain("added")
+  })
+})

package/src/server/skill-discovery.ts

@@ -0,0 +1,77 @@
+import { readdir } from "node:fs/promises"
+import { join } from "node:path"
+import { homedir } from "node:os"
+import { LOG_PREFIX } from "../shared/branding"
+
+async function listSkillNames(dir: string): Promise<string[]> {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true })
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === "ENOENT") return []
+    const message = error instanceof Error ? error.message : String(error)
+    console.warn(`${LOG_PREFIX} Failed to scan skills dir ${dir}: ${message}`)
+    return []
+  }
+}
+
+export async function scanSkillDirs(workspacePath: string, homeDir?: string): Promise<string[]> {
+  const home = homeDir ?? homedir()
+  const userSkillsDir = join(home, ".claude", "skills")
+  const projectSkillsDir = join(workspacePath, ".claude", "skills")
+
+  const [userSkills, projectSkills] = await Promise.all([
+    listSkillNames(userSkillsDir),
+    listSkillNames(projectSkillsDir),
+  ])
+
+  const seen = new Set<string>()
+  const merged: string[] = []
+  for (const name of [...projectSkills, ...userSkills]) {
+    if (!seen.has(name)) {
+      seen.add(name)
+      merged.push(name)
+    }
+  }
+  return merged.sort()
+}
+
+interface CacheEntry {
+  skills: string[]
+  expiresAt: number
+}
+
+interface SkillCacheOptions {
+  ttlMs?: number
+  homeDir?: string
+}
+
+export class SkillCache {
+  private readonly cache = new Map<string, CacheEntry>()
+  private readonly ttlMs: number
+  private readonly homeDir: string | undefined
+
+  constructor(options?: SkillCacheOptions) {
+    this.ttlMs = options?.ttlMs ?? 30_000
+    this.homeDir = options?.homeDir
+  }
+
+  async get(workspacePath: string): Promise<string[]> {
+    const entry = this.cache.get(workspacePath)
+    if (entry && Date.now() < entry.expiresAt) {
+      return entry.skills
+    }
+
+    const skills = await scanSkillDirs(workspacePath, this.homeDir)
+    this.cache.set(workspacePath, { skills, expiresAt: Date.now() + this.ttlMs })
+    return skills
+  }
+
+  invalidate(workspacePath?: string): void {
+    if (workspacePath) {
+      this.cache.delete(workspacePath)
+    } else {
+      this.cache.clear()
+    }
+  }
+}

package/src/server/storage/test-helpers.ts

@@ -0,0 +1,67 @@
+// In-memory EventStore stub for unit tests.
+// Implements only the subset of EventStore methods required by tool-callback
+// and related MCP tool tests.
+
+import type { ToolRequest, ToolRequestStatus, ToolRequestDecision } from "../../shared/permission-policy"
+import { POLICY_TERMINAL_STATUSES } from "../../shared/permission-policy"
+import type { EventStore } from "../event-store"
+
+export function createTestStorage(): { dir: string; cleanup: () => Promise<void> } {
+  throw new Error("test-helpers stub — implement when activating PTY mcp-tool tests")
+}
+
+interface InMemoryEventStore {
+  initialize(): Promise<void>
+  putToolRequest(req: ToolRequest): Promise<void>
+  getToolRequest(id: string): ToolRequest | null
+  listPendingToolRequests(chatId: string): ToolRequest[]
+  resolveToolRequest(
+    id: string,
+    update: { status: ToolRequestStatus; decision: ToolRequestDecision; resolvedAt: number; mismatchReason?: string },
+  ): Promise<void>
+  scanAllToolRequests(): ToolRequest[]
+}
+
+export function createTestEventStore(_dataDir?: string): EventStore {
+  const requests = new Map<string, ToolRequest>()
+
+  const store: InMemoryEventStore = {
+    async initialize() {
+      // No-op for in-memory store
+    },
+
+    async putToolRequest(req: ToolRequest): Promise<void> {
+      requests.set(req.id, { ...req })
+    },
+
+    getToolRequest(id: string): ToolRequest | null {
+      return requests.get(id) ?? null
+    },
+
+    listPendingToolRequests(chatId: string): ToolRequest[] {
+      const result: ToolRequest[] = []
+      for (const req of requests.values()) {
+        if (req.chatId === chatId && !POLICY_TERMINAL_STATUSES.has(req.status)) {
+          result.push({ ...req })
+        }
+      }
+      return result
+    },
+
+    async resolveToolRequest(
+      id: string,
+      update: { status: ToolRequestStatus; decision: ToolRequestDecision; resolvedAt: number; mismatchReason?: string },
+    ): Promise<void> {
+      const existing = requests.get(id)
+      if (existing) {
+        requests.set(id, { ...existing, ...update })
+      }
+    },
+
+    scanAllToolRequests(): ToolRequest[] {
+      return Array.from(requests.values()).map((r) => ({ ...r }))
+    },
+  }
+
+  return store as unknown as EventStore
+}

package/src/server/terminal-manager.test.ts

@@ -0,0 +1,309 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test"
+import { mkdtemp, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { TerminalManager } from "./terminal-manager"
+
+const SHELL_START_TIMEOUT_MS = 5_000
+const COMMAND_TIMEOUT_MS = 5_000
+const FOCUS_IN_SEQUENCE = "\x1b[I"
+const RAW_READ_HEX_COMMAND = `python3 -c "exec('import os,sys,tty,termios,select\\nfd=sys.stdin.fileno()\\nold=termios.tcgetattr(fd)\\ntty.setraw(fd)\\ntry:\\n    sys.stdout.write(\"__RAW_READY__\\\\n\")\\n    sys.stdout.flush()\\n    r,_,_=select.select([fd],[],[],1)\\n    data=os.read(fd,8) if r else b\"\"\\n    print(data.hex() or \"__EMPTY__\")\\nfinally:\\n    termios.tcsetattr(fd, termios.TCSADRAIN, old)')"\r`
+
+const isSupportedPlatform = process.platform !== "win32" && typeof Bun.Terminal === "function"
+const describeIfSupported = isSupportedPlatform ? describe : describe.skip
+
+let tempProjectPath = ""
+const originalTestShell = process.env.TINKARIA_SHELL
+
+beforeAll(async () => {
+  if (!isSupportedPlatform) return
+  process.env.TINKARIA_SHELL = "/bin/sh"
+  tempProjectPath = await mkdtemp(path.join(os.tmpdir(), "tinkaria-terminal-manager-"))
+})
+
+afterAll(() => {
+  if (originalTestShell === undefined) {
+    delete process.env.TINKARIA_SHELL
+    return
+  }
+
+  process.env.TINKARIA_SHELL = originalTestShell
+})
+
+afterEach(async () => {
+  if (!tempProjectPath) return
+  await rm(tempProjectPath, { recursive: true, force: true })
+  tempProjectPath = await mkdtemp(path.join(os.tmpdir(), "tinkaria-terminal-manager-"))
+})
+
+async function waitFor(check: () => boolean, timeoutMs: number, intervalMs = 25) {
+  const startedAt = Date.now()
+  while (Date.now() - startedAt < timeoutMs) {
+    if (check()) return
+    await Bun.sleep(intervalMs)
+  }
+  throw new Error(`Timed out after ${timeoutMs}ms`)
+}
+
+async function createSession(terminalId: string) {
+  const manager = new TerminalManager()
+  let output = ""
+  manager.onEvent((event) => {
+    if (event.type === "terminal.output" && event.terminalId === terminalId) {
+      output += event.data
+    }
+  })
+
+  manager.createTerminal({
+    workspacePath: tempProjectPath,
+    terminalId,
+    cols: 80,
+    rows: 24,
+    scrollback: 1_000,
+  })
+
+  manager.write(terminalId, "printf '__KANNA_READY__\\n'\r")
+  await waitFor(() => output.includes("__KANNA_READY__"), SHELL_START_TIMEOUT_MS)
+  await waitForTerminalToSettle(() => output)
+
+  return {
+    manager,
+    getOutput: () => output,
+  }
+}
+
+async function waitForOutputToContain(getOutput: () => string, value: string, timeoutMs = COMMAND_TIMEOUT_MS) {
+  await waitFor(() => getOutput().includes(value), timeoutMs)
+}
+
+async function waitForTerminalToSettle(getOutput: () => string, idleMs = 75, timeoutMs = COMMAND_TIMEOUT_MS) {
+  let lastOutput = getOutput()
+  let unchangedSince = Date.now()
+
+  await waitFor(() => {
+    const currentOutput = getOutput()
+    if (currentOutput !== lastOutput) {
+      lastOutput = currentOutput
+      unchangedSince = Date.now()
+      return false
+    }
+
+    return Date.now() - unchangedSince >= idleMs
+  }, timeoutMs)
+}
+
+describeIfSupported("TerminalManager", () => {
+  test("ctrl+c interrupts the foreground job and keeps the shell alive", async () => {
+    const terminalId = "terminal-ctrl-c-foreground"
+    const { manager, getOutput } = await createSession(terminalId)
+
+    try {
+      manager.write(terminalId, 'python3 -c "import time; time.sleep(30)"\r')
+      await waitFor(() => getOutput().includes("time.sleep(30)"), COMMAND_TIMEOUT_MS)
+
+      manager.write(terminalId, "\x03")
+      manager.write(terminalId, "printf '__KANNA_AFTER_INT__\\n'\r")
+
+      await waitFor(() => getOutput().includes("__KANNA_AFTER_INT__"), COMMAND_TIMEOUT_MS)
+
+      const snapshot = manager.getSnapshot(terminalId)
+      expect(snapshot?.status).toBe("running")
+      expect(getOutput()).toContain("__KANNA_AFTER_INT__")
+    } finally {
+      manager.close(terminalId)
+    }
+  })
+
+  test("ctrl+c at an idle prompt does not exit the shell", async () => {
+    const terminalId = "terminal-ctrl-c-prompt"
+    const { manager, getOutput } = await createSession(terminalId)
+
+    try {
+      const before = getOutput()
+      manager.write(terminalId, "\x03")
+
+      await waitFor(() => getOutput().length > before.length, COMMAND_TIMEOUT_MS)
+
+      const snapshot = manager.getSnapshot(terminalId)
+      expect(snapshot?.status).toBe("running")
+      expect(getOutput().length).toBeGreaterThan(before.length)
+    } finally {
+      manager.close(terminalId)
+    }
+  })
+
+  test("ctrl+d preserves eof behavior", async () => {
+    const terminalId = "terminal-ctrl-d"
+    const { manager, getOutput } = await createSession(terminalId)
+
+    try {
+      manager.write(terminalId, "printf '__KANNA_CTRL_D_READY__\\n'\r")
+      await waitFor(() => getOutput().includes("__KANNA_CTRL_D_READY__"), COMMAND_TIMEOUT_MS)
+      await waitForTerminalToSettle(getOutput, 200)
+
+      manager.write(terminalId, "\x04")
+
+      await waitFor(() => manager.getSnapshot(terminalId)?.status === "exited", COMMAND_TIMEOUT_MS)
+
+      expect(manager.getSnapshot(terminalId)?.exitCode).toBe(0)
+    } finally {
+      manager.close(terminalId)
+    }
+  })
+
+  test("filters leaked focus reports while focus mode is disabled", async () => {
+    const terminalId = "terminal-focus-filtered"
+    const { manager, getOutput } = await createSession(terminalId)
+
+    try {
+      const beforeLength = getOutput().length
+      manager.write(terminalId, RAW_READ_HEX_COMMAND)
+      await waitForOutputToContain(getOutput, "__RAW_READY__")
+
+      manager.write(terminalId, FOCUS_IN_SEQUENCE)
+      await waitForOutputToContain(getOutput, "__EMPTY__")
+
+      const interactionOutput = getOutput().slice(beforeLength)
+      expect(interactionOutput).toContain("__EMPTY__")
+      expect(interactionOutput).not.toContain("1b5b49")
+    } finally {
+      manager.close(terminalId)
+    }
+  })
+
+  test("forwards focus reports when the session mode is enabled", () => {
+    const manager = new TerminalManager() as unknown as {
+      sessions: Map<
+        string,
+        {
+          status: "running" | "exited"
+          focusReportingEnabled: boolean
+          terminal: { write: (data: string) => void }
+          process: Bun.Subprocess | null
+        }
+      >
+      write: (terminalId: string, data: string) => void
+    }
+    const writes: string[] = []
+
+    manager.sessions.set("terminal-focus-forwarded", {
+      status: "running",
+      focusReportingEnabled: true,
+      terminal: {
+        write(data: string) {
+          writes.push(data)
+        },
+      },
+      process: null,
+    })
+
+    manager.write("terminal-focus-forwarded", FOCUS_IN_SEQUENCE)
+
+    expect(writes).toEqual([FOCUS_IN_SEQUENCE])
+  })
+
+  test("resize signals the shell process group with SIGWINCH", () => {
+    const manager = new TerminalManager() as unknown as {
+      sessions: Map<
+        string,
+        {
+          cols: number
+          rows: number
+          headless: { resize: (cols: number, rows: number) => void }
+          terminal: { resize: (cols: number, rows: number) => void }
+          process: { pid: number } | null
+        }
+      >
+      resize: (terminalId: string, cols: number, rows: number) => void
+    }
+    const resizeCalls: Array<{ cols: number; rows: number }> = []
+    const killCalls: Array<{ pid: number; signal: NodeJS.Signals }> = []
+    const originalKill = process.kill
+
+    ;(process as typeof process & {
+      kill: (pid: number, signal?: NodeJS.Signals | number) => boolean
+    }).kill = ((pid: number, signal?: NodeJS.Signals | number) => {
+      if (typeof signal === "string") {
+        killCalls.push({ pid, signal })
+      }
+      return true
+    }) as typeof process.kill
+
+    manager.sessions.set("terminal-resize-sigwinch", {
+      cols: 80,
+      rows: 24,
+      headless: {
+        resize(cols, rows) {
+          resizeCalls.push({ cols, rows })
+        },
+      },
+      terminal: {
+        resize(cols, rows) {
+          resizeCalls.push({ cols, rows })
+        },
+      },
+      process: { pid: 4321 },
+    })
+
+    try {
+      manager.resize("terminal-resize-sigwinch", 120, 40)
+    } finally {
+      process.kill = originalKill
+    }
+
+    expect(resizeCalls).toEqual([
+      { cols: 120, rows: 40 },
+      { cols: 120, rows: 40 },
+    ])
+    expect(killCalls).toContainEqual({ pid: -4321, signal: "SIGWINCH" })
+  })
+
+  test("new sessions reset focus mode back to filtered", async () => {
+    const manager = new TerminalManager()
+    const firstTerminalId = "terminal-focus-first"
+    const secondTerminalId = "terminal-focus-second"
+    let outputByTerminalId = new Map<string, string>()
+
+    manager.onEvent((event) => {
+      if (event.type !== "terminal.output") return
+      outputByTerminalId.set(event.terminalId, `${outputByTerminalId.get(event.terminalId) ?? ""}${event.data}`)
+    })
+
+    const getOutput = (terminalId: string) => outputByTerminalId.get(terminalId) ?? ""
+
+    const createManagedSession = async (terminalId: string) => {
+      manager.createTerminal({
+        workspacePath: tempProjectPath,
+        terminalId,
+        cols: 80,
+        rows: 24,
+        scrollback: 1_000,
+      })
+      manager.write(terminalId, "printf '__KANNA_READY__\\n'\r")
+      await waitForOutputToContain(() => getOutput(terminalId), "__KANNA_READY__", SHELL_START_TIMEOUT_MS)
+    }
+
+    try {
+      await createManagedSession(firstTerminalId)
+      const firstBeforeLength = getOutput(firstTerminalId).length
+      manager.write(firstTerminalId, "printf '\\033[?1004h'\r")
+      await waitFor(() => getOutput(firstTerminalId).length > firstBeforeLength, COMMAND_TIMEOUT_MS)
+      manager.close(firstTerminalId)
+
+      await createManagedSession(secondTerminalId)
+      const before = getOutput(secondTerminalId).length
+      manager.write(secondTerminalId, "cat -v\r")
+      await waitFor(() => getOutput(secondTerminalId).length > before, COMMAND_TIMEOUT_MS)
+      manager.write(secondTerminalId, FOCUS_IN_SEQUENCE)
+      manager.write(secondTerminalId, "\x03")
+      manager.write(secondTerminalId, "printf '__KANNA_FRESH_SESSION__\\n'\r")
+      await waitForOutputToContain(() => getOutput(secondTerminalId), "__KANNA_FRESH_SESSION__")
+
+      const interactionOutput = getOutput(secondTerminalId).slice(before)
+      expect(interactionOutput).not.toContain("^[[I")
+    } finally {
+      manager.close(firstTerminalId)
+      manager.close(secondTerminalId)
+    }
+  })
+})