airaknit 1.1.2-rc.9

package/src/server/claude-pty-mcp/tools/write.adapter.ts

@@ -0,0 +1,60 @@
+import { z } from "zod"
+import { mkdir, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { homedir } from "node:os"
+import type { ToolCallbackService } from "../../claude-pty/tool-callback"
+import type { ToolHandlerContext, ToolHandlerResult } from "./tool-callback-shim"
+import { gatedToolCall } from "./tool-callback-shim"
+
+const InputSchema = z.object({
+  path: z.string(),
+  content: z.string(),
+})
+
+export type WriteInput = z.infer<typeof InputSchema>
+
+export interface WriteTool {
+  name: "write"
+  schema: typeof InputSchema
+  handler: (input: WriteInput, ctx: ToolHandlerContext) => Promise<ToolHandlerResult>
+}
+
+function resolvePath(p: string, cwd: string): string {
+  if (p.startsWith("~")) return path.join(homedir(), p.slice(1).replace(/^\//, ""))
+  return path.resolve(cwd, p)
+}
+
+export function createWriteTool(deps: { toolCallback: ToolCallbackService }): WriteTool {
+  return {
+    name: "write",
+    schema: InputSchema,
+    async handler(input, ctx) {
+      return gatedToolCall({
+        toolCallback: deps.toolCallback,
+        toolName: "mcp__kanna__write",
+        ctx,
+        args: input as unknown as Record<string, unknown>,
+        formatAnswer: async () => {
+          const resolved = resolvePath(input.path, ctx.cwd)
+          try {
+            await mkdir(path.dirname(resolved), { recursive: true })
+            await writeFile(resolved, input.content, "utf8")
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err)
+            return {
+              content: [{ type: "text" as const, text: `Error writing file: ${msg}` }],
+              isError: true,
+            }
+          }
+          return {
+            content: [{ type: "text" as const, text: `File written: ${resolved}` }],
+          }
+        },
+        formatDeny: (reason) => ({
+          content: [{ type: "text" as const, text: `Denied: ${reason}` }],
+          isError: true,
+        }),
+      })
+    },
+  }
+}

package/src/server/claude-pty-mcp/tools/write.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtemp, rm, readFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { POLICY_DEFAULT } from "../../../shared/permission-policy"
+import { createToolCallbackService } from "../../claude-pty/tool-callback"
+import { createTestEventStore } from "../../storage/test-helpers"
+import { createWriteTool } from "./write.adapter"
+
+async function newStore() {
+  const dir = await mkdtemp(path.join(tmpdir(), "kanna-mcp-write-"))
+  const store = createTestEventStore(dir)
+  await store.initialize()
+  const cleanup = async () => {
+    await new Promise<void>((r) => setTimeout(r, 50))
+    await rm(dir, { recursive: true, force: true })
+  }
+  return { store, dir, cleanup }
+}
+
+const ctx = (cwd: string) => ({
+  chatId: "c",
+  sessionId: "s",
+  toolUseId: "tu",
+  cwd,
+  chatPolicy: { ...POLICY_DEFAULT, defaultAction: "auto-allow" as const },
+})
+
+describe("mcp__kanna__write", () => {
+  test("writes file content", async () => {
+    const { store, dir, cleanup } = await newStore()
+    try {
+      const svc = createToolCallbackService({ store, serverSecret: "k", now: () => 1, timeoutMs: 600_000 })
+      const tool = createWriteTool({ toolCallback: svc })
+      const filePath = path.join(dir, "subdir", "output.txt")
+      const result = await tool.handler({ path: filePath, content: "written content" }, ctx(dir))
+      expect(result.isError).toBeFalsy()
+      const read = await readFile(filePath, "utf8")
+      expect(read).toBe("written content")
+    } finally { await cleanup() }
+  }, 30_000)
+
+  test("path in writePathDeny → isError", async () => {
+    const { store, dir, cleanup } = await newStore()
+    try {
+      const svc = createToolCallbackService({ store, serverSecret: "k", now: () => 1, timeoutMs: 600_000 })
+      const tool = createWriteTool({ toolCallback: svc })
+      const result = await tool.handler({ path: "~/.ssh/authorized_keys", content: "key data" }, ctx(dir))
+      expect(result.isError).toBe(true)
+    } finally { await cleanup() }
+  }, 30_000)
+})

package/src/server/claude-pty-mcp/uploads.adapter.ts

@@ -0,0 +1,98 @@
+import { randomUUID } from "node:crypto"
+import { mkdir, open, rm } from "node:fs/promises"
+import path from "node:path"
+import { fileTypeFromBuffer } from "file-type"
+import type { ChatAttachment } from "../../shared/types"
+import { getProjectUploadDir } from "./paths"
+
+const DEFAULT_BINARY_MIME_TYPE = "application/octet-stream"
+const IMAGE_MIME_PREFIX = "image/"
+
+function sanitizeFileName(fileName: string) {
+  const baseName = path.basename(fileName).trim()
+  const cleaned = baseName.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "")
+  return cleaned || "upload"
+}
+
+function getUploadCandidateNames(originalName: string) {
+  const sanitizedName = sanitizeFileName(originalName)
+  const parsed = path.parse(sanitizedName)
+  const extension = parsed.ext
+  const name = parsed.name || "upload"
+
+  return {
+    first: sanitizedName,
+    withCounter(counter: number) {
+      return `${name}-${counter}${extension}`
+    },
+  }
+}
+
+export async function persistProjectUpload(args: {
+  projectId: string
+  localPath: string
+  fileName: string
+  bytes: Uint8Array
+  fallbackMimeType?: string
+}): Promise<ChatAttachment> {
+  const uploadDir = getProjectUploadDir(args.localPath)
+  await mkdir(uploadDir, { recursive: true })
+
+  const detectedType = await fileTypeFromBuffer(args.bytes)
+  const mimeType = detectedType?.mime ?? args.fallbackMimeType ?? DEFAULT_BINARY_MIME_TYPE
+  const candidates = getUploadCandidateNames(args.fileName)
+
+  let storedName = candidates.first
+  let absolutePath = path.join(uploadDir, storedName)
+  let counter = 1
+
+  while (true) {
+    try {
+      const handle = await open(absolutePath, "wx")
+      try {
+        await handle.writeFile(args.bytes)
+      } finally {
+        await handle.close()
+      }
+      break
+    } catch (error) {
+      const code = error instanceof Error && "code" in error ? (error as NodeJS.ErrnoException).code : undefined
+      if (code !== "EEXIST") {
+        throw error
+      }
+
+      storedName = candidates.withCounter(counter)
+      absolutePath = path.join(uploadDir, storedName)
+      counter += 1
+    }
+  }
+
+  return {
+    id: randomUUID(),
+    kind: mimeType.startsWith(IMAGE_MIME_PREFIX) ? "image" : "file",
+    displayName: args.fileName,
+    absolutePath,
+    relativePath: `./.kanna/uploads/${storedName}`,
+    contentUrl: `/api/projects/${args.projectId}/uploads/${encodeURIComponent(storedName)}/content`,
+    mimeType,
+    size: args.bytes.byteLength,
+  }
+}
+
+export async function deleteProjectUpload(args: {
+  localPath: string
+  storedName: string
+}): Promise<boolean> {
+  const storedName = args.storedName
+  if (!storedName || storedName.includes("/") || storedName.includes("\\") || storedName === "." || storedName === "..") {
+    return false
+  }
+
+  const absolutePath = path.join(getProjectUploadDir(args.localPath), storedName)
+  try {
+    await rm(absolutePath, { force: true })
+    return true
+  } catch {
+    return false
+  }
+}

package/src/server/claude-pty-mcp/uploads.ts

@@ -0,0 +1,38 @@
+import path from "node:path"
+
+export { persistProjectUpload, deleteProjectUpload } from "./uploads.adapter"
+
+const TEXT_PLAIN_CONTENT_TYPE = "text/plain; charset=utf-8"
+const DEFAULT_BINARY_MIME_TYPE = "application/octet-stream"
+
+const TEXT_CONTENT_TYPE_BY_EXTENSION = new Map<string, string>([
+  [".csv", "text/csv; charset=utf-8"],
+  [".json", "application/json; charset=utf-8"],
+  [".jsonc", TEXT_PLAIN_CONTENT_TYPE],
+  [".md", "text/markdown; charset=utf-8"],
+  [".tsv", "text/tab-separated-values; charset=utf-8"],
+])
+
+const TEXT_LIKE_EXTENSIONS = new Set([
+  ".c", ".cc", ".cfg", ".conf", ".cpp", ".cs", ".css", ".env", ".go", ".graphql", ".h", ".hpp", ".html",
+  ".ini", ".java", ".js", ".jsx", ".kt", ".lua", ".mjs", ".php", ".pl", ".properties", ".py", ".rb", ".rs",
+  ".scss", ".sh", ".sql", ".swift", ".toml", ".ts", ".tsx", ".txt", ".vue", ".xml", ".yaml", ".yml", ".zsh",
+])
+
+export function inferAttachmentContentType(fileName: string, fallbackType?: string): string {
+  const extension = path.extname(fileName).toLowerCase()
+  const mappedType = TEXT_CONTENT_TYPE_BY_EXTENSION.get(extension)
+  if (mappedType) {
+    return mappedType
+  }
+
+  if (TEXT_LIKE_EXTENSIONS.has(extension)) {
+    return TEXT_PLAIN_CONTENT_TYPE
+  }
+
+  return fallbackType || DEFAULT_BINARY_MIME_TYPE
+}
+
+export function inferProjectFileContentType(fileName: string, fallbackType?: string): string {
+  return inferAttachmentContentType(fileName, fallbackType)
+}

package/src/server/claude-turn.test.ts

@@ -0,0 +1,176 @@
+import { afterEach, describe, expect, mock, test } from "bun:test"
+import { startClaudeTurn, type ClaudeSdkBinding } from "./claude-harness"
+import type { ResolveClaudeBinaryResult } from "./claude-pty/resolve-binary.adapter"
+
+const warmQueryCalls: string[] = []
+const directQueryCalls: Array<{ prompt: string; options?: Record<string, unknown> }> = []
+const interruptMock = mock(async () => {})
+const closeMock = mock(() => {})
+const accountInfoMock = mock(async () => null)
+const contextUsageMock = mock(async () => null)
+
+/** Fake binary resolver that short-circuits real fs/PATH lookups in unit tests. */
+const fakeBinaryResolver = async (): Promise<ResolveClaudeBinaryResult> => ({
+  path: "/fake/claude",
+  source: "PATH",
+  triedPaths: ["PATH lookup: /fake/claude"],
+})
+
+function createQuery(model = "claude-sonnet-4-5") {
+  return {
+    async *[Symbol.asyncIterator]() {
+      yield { session_id: "claude-session-1" }
+      yield {
+        type: "system",
+        subtype: "init",
+        session_id: "claude-session-1",
+        model,
+        tools: [],
+        agents: [],
+        slash_commands: [],
+        mcp_servers: [],
+      }
+      yield {
+        type: "result",
+        subtype: "success",
+        session_id: "claude-session-1",
+        is_error: false,
+        duration_ms: 1,
+        result: "ok",
+      }
+    },
+    accountInfo: accountInfoMock,
+    getContextUsage: contextUsageMock,
+    interrupt: interruptMock,
+    close: closeMock,
+  }
+}
+
+async function collect(iterable: AsyncIterable<unknown>) {
+  const items: unknown[] = []
+  for await (const item of iterable) {
+    items.push(item)
+  }
+  return items
+}
+
+afterEach(() => {
+  interruptMock.mockClear()
+  closeMock.mockClear()
+  accountInfoMock.mockClear()
+  contextUsageMock.mockClear()
+  warmQueryCalls.length = 0
+  directQueryCalls.length = 0
+})
+
+describe("startClaudeTurn", () => {
+  test("bootstraps Claude turns through startup().query() so the first prompt is carried into fresh spawned sessions", async () => {
+    const sdk: ClaudeSdkBinding = {
+      query() {
+        throw new Error("query() should not be used for Claude bootstrap")
+      },
+      startup: mock(async ({ options }: { options?: Record<string, unknown> } = {}) => ({
+        query(prompt: string) {
+          warmQueryCalls.push(prompt)
+          return createQuery((options?.model as string | undefined) ?? "claude-sonnet-4-5") as never
+        },
+      })),
+    }
+
+    const turn = await startClaudeTurn({
+      content: "Delegated task:\nFix the regression",
+      localPath: "/tmp/project",
+      model: "claude-sonnet-4-5",
+      planMode: false,
+      sessionToken: null,
+      onToolRequest: async () => ({}),
+      chatId: "chat-1",
+      sdk,
+      _resolveBinary: fakeBinaryResolver,
+    })
+
+    const events = await collect(turn.stream)
+
+    expect(sdk.startup).toHaveBeenCalledTimes(1)
+    expect(warmQueryCalls).toEqual(["Delegated task:\nFix the regression"])
+    expect(events.some((event) => (
+      typeof event === "object" &&
+      event !== null &&
+      "type" in event &&
+      (event as { type?: string }).type === "session_token"
+    ))).toBe(true)
+    expect(events.some((event) => (
+      typeof event === "object" &&
+      event !== null &&
+      "type" in event &&
+      (event as { type?: string; entry?: { kind?: string; provider?: string } }).type === "transcript" &&
+      (event as { entry?: { kind?: string; provider?: string } }).entry?.kind === "system_init" &&
+      (event as { entry?: { kind?: string; provider?: string } }).entry?.provider === "claude"
+    ))).toBe(true)
+    expect(events.some((event) => (
+      typeof event === "object" &&
+      event !== null &&
+      "type" in event &&
+      (event as { type?: string; entry?: { kind?: string; isError?: boolean; result?: string } }).type === "transcript" &&
+      (event as { entry?: { kind?: string; isError?: boolean; result?: string } }).entry?.kind === "result" &&
+      (event as { entry?: { kind?: string; isError?: boolean; result?: string } }).entry?.isError === false &&
+      (event as { entry?: { kind?: string; isError?: boolean; result?: string } }).entry?.result === "ok"
+    ))).toBe(true)
+
+    await turn.interrupt()
+    turn.close()
+    expect(interruptMock).toHaveBeenCalledTimes(1)
+    expect(closeMock).toHaveBeenCalledTimes(1)
+  })
+
+  test("falls back to direct query when startup() is unavailable", async () => {
+    const sdk: ClaudeSdkBinding = {
+      query(args) {
+        directQueryCalls.push(args as unknown as { prompt: string; options?: Record<string, unknown> })
+        return createQuery(args.options?.model ?? "claude-sonnet-4-5") as never
+      },
+    }
+
+    const turn = await startClaudeTurn({
+      content: "Direct bootstrap prompt",
+      localPath: "/tmp/project",
+      model: "claude-sonnet-4-5",
+      planMode: false,
+      sessionToken: null,
+      onToolRequest: async () => ({}),
+      sdk,
+      _resolveBinary: fakeBinaryResolver,
+    })
+
+    await collect(turn.stream)
+
+    expect(directQueryCalls).toHaveLength(1)
+    expect(directQueryCalls[0]?.prompt).toBe("Direct bootstrap prompt")
+    expect(directQueryCalls[0]?.options?.cwd).toBe("/tmp/project")
+  })
+
+  test("resolves binary runner-side and passes path to pathToClaudeCodeExecutable", async () => {
+    // Capture the options passed to the SDK so we can assert on pathToClaudeCodeExecutable.
+    let capturedOptions: Record<string, unknown> | undefined
+    const sdk: ClaudeSdkBinding = {
+      query(args) {
+        capturedOptions = args.options as Record<string, unknown>
+        return createQuery() as never
+      },
+    }
+
+    const fakePath = "/usr/local/bin/claude-custom"
+    await startClaudeTurn({
+      content: "test",
+      localPath: "/tmp/project",
+      model: "claude-sonnet-4-5",
+      planMode: false,
+      sessionToken: null,
+      onToolRequest: async () => ({}),
+      sdk,
+      _resolveBinary: async () => ({ path: fakePath, source: "PATH", triedPaths: [] }),
+    }).then((t) => collect(t.stream))
+
+    expect(capturedOptions?.pathToClaudeCodeExecutable).toBe(fakePath)
+  })
+})