@shareai-lab/kode 1.1.14 → 1.1.16-dev.2

package/src/utils/permissions/filesystem.ts

@@ -1,127 +0,0 @@
-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

@@ -1,23 +0,0 @@
-/**
- * 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

@@ -1,167 +0,0 @@
-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)
-  }
-}