@shareai-lab/kode 1.0.9

package/src/utils/permissions/filesystem.ts

@@ -0,0 +1,127 @@
+import { isAbsolute, resolve, relative, sep } from 'path'
+import { getCwd, getOriginalCwd } from '../state'
+
+// In-memory storage for file permissions that resets each session
+// Sets of allowed directories for read and write operations
+const readFileAllowedDirectories: Set<string> = new Set()
+const writeFileAllowedDirectories: Set<string> = new Set()
+
+/**
+ * Ensures a path is absolute by resolving it relative to cwd if necessary
+ * @param path The path to normalize
+ * @returns Absolute path
+ */
+export function toAbsolutePath(path: string): string {
+  const abs = isAbsolute(path) ? resolve(path) : resolve(getCwd(), path)
+  return normalizeForCompare(abs)
+}
+
+function normalizeForCompare(p: string): string {
+  // Normalize separators and resolve .. and . segments
+  const norm = resolve(p)
+  // On Windows, comparisons should be case-insensitive
+  return process.platform === 'win32' ? norm.toLowerCase() : norm
+}
+
+function isSubpath(base: string, target: string): boolean {
+  const rel = relative(base, target)
+  // If different drive letters on Windows, relative returns the target path
+  if (!rel || rel === '') return true
+  // Not a subpath if it goes up to parent
+  if (rel.startsWith('..')) return false
+  // Not a subpath if absolute
+  if (isAbsolute(rel)) return false
+  return true
+}
+
+/**
+ * Ensures a path is in the original cwd path
+ * @param directory The directory path to normalize
+ * @returns Absolute path
+ */
+export function pathInOriginalCwd(path: string): boolean {
+  const absolutePath = toAbsolutePath(path)
+  const base = toAbsolutePath(getOriginalCwd())
+  return isSubpath(base, absolutePath)
+}
+
+/**
+ * Check if read permission exists for the specified directory
+ * @param directory The directory to check permission for
+ * @returns true if read permission exists, false otherwise
+ */
+export function hasReadPermission(directory: string): boolean {
+  const absolutePath = toAbsolutePath(directory)
+  for (const allowedPath of readFileAllowedDirectories) {
+    if (isSubpath(allowedPath, absolutePath)) return true
+  }
+  return false
+}
+
+/**
+ * Check if write permission exists for the specified directory
+ * @param directory The directory to check permission for
+ * @returns true if write permission exists, false otherwise
+ */
+export function hasWritePermission(directory: string): boolean {
+  const absolutePath = toAbsolutePath(directory)
+  for (const allowedPath of writeFileAllowedDirectories) {
+    if (isSubpath(allowedPath, absolutePath)) return true
+  }
+  return false
+}
+
+/**
+ * Save read permission for a directory
+ * @param directory The directory to grant read permission for
+ */
+function saveReadPermission(directory: string): void {
+  const absolutePath = toAbsolutePath(directory)
+  // Remove any existing subpaths contained by this new path
+  for (const allowedPath of Array.from(readFileAllowedDirectories)) {
+    if (isSubpath(absolutePath, allowedPath)) {
+      readFileAllowedDirectories.delete(allowedPath)
+    }
+  }
+  readFileAllowedDirectories.add(absolutePath)
+}
+
+export const saveReadPermissionForTest = saveReadPermission
+
+/**
+ * Grants read permission for the original project directory.
+ * This is useful for initializing read access to the project root.
+ */
+export function grantReadPermissionForOriginalDir(): void {
+  const originalProjectDir = getOriginalCwd()
+  saveReadPermission(originalProjectDir)
+}
+
+/**
+ * Save write permission for a directory
+ * @param directory The directory to grant write permission for
+ */
+function saveWritePermission(directory: string): void {
+  const absolutePath = toAbsolutePath(directory)
+  for (const allowedPath of Array.from(writeFileAllowedDirectories)) {
+    if (isSubpath(absolutePath, allowedPath)) {
+      writeFileAllowedDirectories.delete(allowedPath)
+    }
+  }
+  writeFileAllowedDirectories.add(absolutePath)
+}
+
+/**
+ * Grants write permission for the original project directory.
+ * This is useful for initializing write access to the project root.
+ */
+export function grantWritePermissionForOriginalDir(): void {
+  const originalProjectDir = getOriginalCwd()
+  saveWritePermission(originalProjectDir)
+}
+
+// For testing purposes
+export function clearFilePermissions(): void {
+  readFileAllowedDirectories.clear()
+  writeFileAllowedDirectories.clear()
+}

package/src/utils/responseState.ts

@@ -0,0 +1,23 @@
+/**
+ * Response state management for Responses API
+ * Tracks previous_response_id for conversation chaining
+ */
+
+// Store the last response ID for each conversation
+const responseIdCache = new Map<string, string>()
+
+export function getLastResponseId(conversationId: string): string | undefined {
+  return responseIdCache.get(conversationId)
+}
+
+export function setLastResponseId(conversationId: string, responseId: string): void {
+  responseIdCache.set(conversationId, responseId)
+}
+
+export function clearResponseId(conversationId: string): void {
+  responseIdCache.delete(conversationId)
+}
+
+export function clearAllResponseIds(): void {
+  responseIdCache.clear()
+}

package/src/utils/ripgrep.ts

@@ -0,0 +1,167 @@
+import { findActualExecutable } from 'spawn-rx'
+import { memoize } from 'lodash-es'
+import { fileURLToPath, resolve } from 'node:url'
+import * as path from 'path'
+import { logError } from './log'
+import { execFileNoThrow } from './execFileNoThrow'
+import { execFile } from 'child_process'
+import debug from 'debug'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = resolve(
+  __filename,
+  process.env.NODE_ENV === 'test' ? '../..' : '.',
+)
+
+const d = debug('claude:ripgrep')
+
+const useBuiltinRipgrep = !!process.env.USE_BUILTIN_RIPGREP
+if (useBuiltinRipgrep) {
+  d('Using builtin ripgrep because USE_BUILTIN_RIPGREP is set')
+}
+
+const ripgrepPath = memoize(() => {
+  const { cmd } = findActualExecutable('rg', [])
+  d(`ripgrep initially resolved as: ${cmd}`)
+
+  if (cmd !== 'rg' && !useBuiltinRipgrep) {
+    // NB: If we're able to find ripgrep in $PATH, cmd will be an absolute
+    // path rather than just returning 'rg'
+    return cmd
+  } else {
+    // Use the one we ship in-box
+    const rgRoot = path.resolve(__dirname, 'vendor', 'ripgrep')
+    if (process.platform === 'win32') {
+      // NB: Ripgrep doesn't ship an aarch64 binary for Windows, boooooo
+      return path.resolve(rgRoot, 'x64-win32', 'rg.exe')
+    }
+
+    const ret = path.resolve(
+      rgRoot,
+      `${process.arch}-${process.platform}`,
+      'rg',
+    )
+
+    d('internal ripgrep resolved as: %s', ret)
+    return ret
+  }
+})
+
+export async function ripGrep(
+  args: string[],
+  target: string,
+  abortSignal: AbortSignal,
+): Promise<string[]> {
+  await codesignRipgrepIfNecessary()
+  const rg = ripgrepPath()
+  d('ripgrep called: %s %o', rg, target, args)
+
+  // NB: When running interactively, ripgrep does not require a path as its last
+  // argument, but when run non-interactively, it will hang unless a path or file
+  // pattern is provided
+  return new Promise(resolve => {
+    execFile(
+      ripgrepPath(),
+      [...args, target],
+      {
+        maxBuffer: 1_000_000,
+        signal: abortSignal,
+        timeout: 10_000,
+      },
+      (error, stdout) => {
+        if (error) {
+          // Exit code 1 from ripgrep means "no matches found" - this is normal
+          if (error.code !== 1) {
+            d('ripgrep error: %o', error)
+            logError(error)
+          }
+          resolve([])
+        } else {
+          d('ripgrep succeeded with %s', stdout)
+          resolve(stdout.trim().split('\n').filter(Boolean))
+        }
+      },
+    )
+  })
+}
+
+// NB: We do something tricky here. We know that ripgrep processes common
+// ignore files for us, so we just ripgrep for any character, which matches
+// all non-empty files
+export async function listAllContentFiles(
+  path: string,
+  abortSignal: AbortSignal,
+  limit: number,
+): Promise<string[]> {
+  try {
+    d('listAllContentFiles called: %s', path)
+    return (await ripGrep(['-l', '.', path], path, abortSignal)).slice(0, limit)
+  } catch (e) {
+    d('listAllContentFiles failed: %o', e)
+
+    logError(e)
+    return []
+  }
+}
+
+let alreadyDoneSignCheck = false
+async function codesignRipgrepIfNecessary() {
+  if (process.platform !== 'darwin' || alreadyDoneSignCheck) {
+    return
+  }
+
+  alreadyDoneSignCheck = true
+
+  // First, check to see if ripgrep is already signed
+  d('checking if ripgrep is already signed')
+  const lines = (
+    await execFileNoThrow(
+      'codesign',
+      ['-vv', '-d', ripgrepPath()],
+      undefined,
+      undefined,
+      false,
+    )
+  ).stdout.split('\n')
+
+  const needsSigned = lines.find(line => line.includes('linker-signed'))
+  if (!needsSigned) {
+    d('seems to be already signed')
+    return
+  }
+
+  try {
+    d('signing ripgrep')
+    const signResult = await execFileNoThrow('codesign', [
+      '--sign',
+      '-',
+      '--force',
+      '--preserve-metadata=entitlements,requirements,flags,runtime',
+      ripgrepPath(),
+    ])
+
+    if (signResult.code !== 0) {
+      d('failed to sign ripgrep: %o', signResult)
+      logError(
+        `Failed to sign ripgrep: ${signResult.stdout} ${signResult.stderr}`,
+      )
+    }
+
+    d('removing quarantine')
+    const quarantineResult = await execFileNoThrow('xattr', [
+      '-d',
+      'com.apple.quarantine',
+      ripgrepPath(),
+    ])
+
+    if (quarantineResult.code !== 0) {
+      d('failed to remove quarantine: %o', quarantineResult)
+      logError(
+        `Failed to remove quarantine: ${quarantineResult.stdout} ${quarantineResult.stderr}`,
+      )
+    }
+  } catch (e) {
+    d('failed during sign: %o', e)
+    logError(e)
+  }
+}