@lkangd/cc-env 1.1.1 → 1.2.0

package/src/ink/restore-app.tsx

@@ -1,230 +0,0 @@
-import React, { useEffect, useMemo, useState } from 'react'
-import { Box, Text, useApp, useInput } from 'ink'
-
-import { advanceRestoreFlow, type RestoreFlowState } from '../flows/restore-flow.js'
-import { EnvEntries, EnvSummary } from './summary.js'
-
-export function RestoreApp({
-  state,
-  onSubmit,
-}: {
-  state: RestoreFlowState
-  onSubmit?: (result: {
-    confirmed: boolean
-    timestamp?: string
-    targetType?: 'settings' | 'preset'
-    targetName?: string
-  }) => void
-}) {
-  const { exit } = useApp()
-  const [currentState, setCurrentState] = useState(state)
-  const [cursor, setCursor] = useState(0)
-  const recordAtCursor = currentState.records[cursor]
-  const selectedRecord = currentState.records.find(
-    (record) => record.timestamp === currentState.selectedTimestamp,
-  )
-  const activeRecord = currentState.step === 'record'
-    ? recordAtCursor
-    : selectedRecord ?? currentState.records[0]
-  const restoreEntries = useMemo(
-    () =>
-      activeRecord
-        ? Object.entries(
-            activeRecord.action === 'init'
-              ? Object.fromEntries(activeRecord.sources.flatMap((s) => Object.entries(s.backup)))
-              : activeRecord.backup,
-          ).sort(([left], [right]) => left.localeCompare(right)) as [string, string][]
-        : [],
-    [activeRecord],
-  )
-
-  const fromFiles = useMemo(() => {
-    if (!activeRecord || activeRecord.action !== 'init') {
-      return []
-    }
-
-    return activeRecord.shellWrites.map((sw) => sw.filePath)
-  }, [activeRecord])
-
-  const toFiles = useMemo(() => {
-    if (!activeRecord || activeRecord.action !== 'init') {
-      return []
-    }
-
-    return activeRecord.sources.map((s) => s.file)
-  }, [activeRecord])
-
-  useEffect(() => {
-    setCurrentState(state)
-    setCursor(0)
-  }, [state])
-
-  useEffect(() => {
-    if (!onSubmit || currentState.records.length !== 0) {
-      return
-    }
-
-    onSubmit({
-      confirmed: false,
-    })
-    exit()
-  }, [currentState.records.length, exit, onSubmit])
-
-  useInput((input, key) => {
-    if (!onSubmit) {
-      return
-    }
-
-    if (key.escape || input.toLowerCase() === 'q') {
-      onSubmit({ confirmed: false })
-      exit()
-      return
-    }
-
-    if (currentState.step === 'record') {
-      if (key.upArrow || input === 'k') {
-        setCursor((value) => Math.max(0, value - 1))
-        return
-      }
-
-      if (key.downArrow || input === 'j') {
-        setCursor((value) => Math.min(currentState.records.length - 1, value + 1))
-        return
-      }
-    }
-
-    if (!key.return || !activeRecord) {
-      return
-    }
-
-    if (currentState.step === 'record') {
-      setCurrentState((previousState) =>
-        advanceRestoreFlow(previousState, {
-          type: 'select-record',
-          timestamp: activeRecord.timestamp,
-        }),
-      )
-      return
-    }
-
-    if (currentState.step === 'target') {
-      if (activeRecord.action !== 'restore') {
-        return
-      }
-
-      setCurrentState((previousState) =>
-        advanceRestoreFlow(previousState, {
-          type: 'select-target',
-          targetType: activeRecord.targetType,
-          ...(activeRecord.targetType === 'preset'
-            ? { targetName: activeRecord.targetName }
-            : {}),
-        }),
-      )
-      return
-    }
-
-    if (currentState.step === 'confirm') {
-      onSubmit({
-        confirmed: true,
-        timestamp: activeRecord.timestamp,
-        ...(currentState.targetType ? { targetType: currentState.targetType } : {}),
-        ...(currentState.targetType === 'preset' && 'targetName' in currentState
-          ? { targetName: currentState.targetName }
-          : {}),
-      })
-      exit()
-    }
-  })
-
-  return (
-    <Box flexDirection="column">
-      <Text>Restore record</Text>
-      {currentState.step === 'record' ? (
-        <>
-          <Text dimColor>↑/k ↓/j navigate · enter confirm · q cancel</Text>
-          <Box marginTop={1}>
-            <Box flexDirection="column" width={28} marginRight={2}>
-              <Text bold color="cyan">History</Text>
-              <Box flexDirection="column" marginTop={1}>
-                {currentState.records.map((record, index) => (
-                  <Text key={record.timestamp}>
-                    {index === cursor ? '❯ ' : '  '}
-                    {record.timestamp}
-                  </Text>
-                ))}
-              </Box>
-            </Box>
-            <Box flexDirection="column" flexGrow={1} borderStyle="round" borderColor="green" paddingX={1}>
-              <Text bold color="green">Preview</Text>
-              {activeRecord?.action === 'init' ? (
-                <Box flexDirection="column">
-                  {fromFiles.length > 0 ? (
-                    <Box flexDirection="column">
-                      <Text dimColor>From:</Text>
-                      {fromFiles.map((file) => (
-                        <Text key={file} color="cyan">  {file}</Text>
-                      ))}
-                    </Box>
-                  ) : null}
-                  {toFiles.length > 0 ? (
-                    <Box flexDirection="column">
-                      <Text dimColor>To:</Text>
-                      {toFiles.map((file) => (
-                        <Text key={file} color="cyan">  {file}</Text>
-                      ))}
-                    </Box>
-                  ) : null}
-                </Box>
-              ) : (
-                <Text dimColor>
-                  Restore to {activeRecord?.targetType === 'preset' ? `preset ${activeRecord.targetName}` : activeRecord?.targetType ?? 'settings'}
-                </Text>
-              )}
-              <Box flexDirection="column" marginTop={1}>
-                <EnvEntries entries={restoreEntries} />
-              </Box>
-            </Box>
-          </Box>
-        </>
-      ) : null}
-      {currentState.step === 'target' ? (
-        <Text>
-          Select target for {selectedRecord?.timestamp ?? 'record'}: settings or preset
-        </Text>
-      ) : null}
-      {currentState.step === 'confirm' && selectedRecord?.action === 'init' ? (
-        <Box flexDirection="column" marginTop={1}>
-          <Text>
-            Confirm restore from <Text color="cyan">{selectedRecord.timestamp}</Text>
-          </Text>
-          <EnvSummary
-            title="Will restore"
-            entries={restoreEntries}
-            {...(fromFiles.length > 0 ? { fromFiles } : {})}
-            {...(toFiles.length > 0 ? { toFiles } : {})}
-          />
-        </Box>
-      ) : null}
-      {currentState.step === 'confirm' && selectedRecord?.action !== 'init' ? (
-        <Box flexDirection="column" marginTop={1}>
-          <Text>
-            Confirm restore from <Text color="cyan">{selectedRecord?.timestamp ?? 'record'}</Text> to{' '}
-            <Text color="green">
-              {currentState.targetType === 'preset'
-                ? `preset ${currentState.targetName}`
-                : currentState.targetType ?? 'settings'}
-            </Text>
-          </Text>
-          <EnvSummary title="Will restore" entries={restoreEntries} />
-        </Box>
-      ) : null}
-      {currentState.step === 'done' ? (
-        <Text color="green">{'\n'}Restore complete</Text>
-      ) : null}
-      {currentState.step !== 'done' ? (
-        <Text>Press Enter to confirm or q to cancel</Text>
-      ) : null}
-    </Box>
-  )
-}

package/src/ink/run-preset-select-app.tsx

@@ -1,83 +0,0 @@
-import React, { useMemo, useState } from 'react'
-import { Box, Text, useApp, useInput } from 'ink'
-
-import type { EnvMap } from '../core/schema.js'
-import { EnvEntries } from './summary.js'
-
-export type PresetSource = 'global' | 'project'
-
-export type PresetSelectItem = {
-  name: string
-  env: EnvMap
-  source: PresetSource
-}
-
-type Props = {
-  presets: Array<PresetSelectItem>
-  defaultIndex?: number
-  onSubmit: (preset: PresetSelectItem) => void
-}
-
-export function RunPresetSelectApp({ presets, defaultIndex = 0, onSubmit }: Props) {
-  const { exit } = useApp()
-  const [cursor, setCursor] = useState(defaultIndex)
-  const active = presets[cursor]
-
-  const entries = useMemo(
-    () =>
-      active
-        ? (Object.entries(active.env).sort(([a], [b]) => a.localeCompare(b)) as [string, string][])
-        : [],
-    [active],
-  )
-
-  useInput((input, key) => {
-    if (key.escape || input.toLowerCase() === 'q') {
-      exit()
-      return
-    }
-
-    if (key.upArrow || input === 'k') {
-      setCursor((c) => Math.max(0, c - 1))
-      return
-    }
-
-    if (key.downArrow || input === 'j') {
-      setCursor((c) => Math.min(presets.length - 1, c + 1))
-      return
-    }
-
-    if (key.return && active) {
-      onSubmit(active)
-      exit()
-    }
-  })
-
-  return (
-    <Box flexDirection="column">
-      <Text bold>Select a preset</Text>
-      <Text dimColor>↑/k ↓/j navigate · enter select · q cancel</Text>
-      <Box marginTop={1}>
-        <Box flexDirection="column" width={28} marginRight={2}>
-          <Text bold color="cyan">Presets</Text>
-          <Box flexDirection="column" marginTop={1}>
-            {presets.map((p, i) => (
-              <Box key={`${p.source}:${p.name}`}>
-                <Text>{i === cursor ? '❯ ' : '  '}</Text>
-                <Text {...(p.source === 'project' ? { color: 'yellow' } : {})}>{p.name}</Text>
-                <Text dimColor> ({p.source})</Text>
-              </Box>
-            ))}
-          </Box>
-        </Box>
-        <Box flexDirection="column" flexGrow={1} borderStyle="round" borderColor="green" paddingX={1}>
-          <Text bold color="green">{active?.name ?? 'Preview'}</Text>
-          <Text dimColor>{active?.source === 'project' ? 'Project preset' : 'Global preset'}</Text>
-          <Box flexDirection="column" marginTop={1}>
-            <EnvEntries entries={entries} />
-          </Box>
-        </Box>
-      </Box>
-    </Box>
-  )
-}

package/src/ink/summary.tsx

@@ -1,91 +0,0 @@
-import React from 'react'
-import type { ReactNode } from 'react'
-import { Box, Text, render } from 'ink'
-
-const h = React.createElement
-
-import { maskValue } from '../core/mask.js'
-import type { EnvMap } from '../core/schema.js'
-
-export function EnvEntries({ entries, mask }: { entries: [string, string][]; mask?: boolean }) {
-  if (entries.length === 0) {
-    return <Text dimColor>none</Text>
-  }
-  return <>{entries.map(([key, value]) => (
-    <Box key={key}>
-      <Text color="yellow">• </Text>
-      <Text color="magenta">{key}</Text>
-      <Text dimColor>=</Text>
-      <Text color="white">{mask ? maskValue(key, value) : value}</Text>
-    </Box>
-  ))}</>
-}
-
-export function EnvSummary({
-  title,
-  entries,
-  description,
-  fromFiles,
-  toFiles,
-  footer,
-  mask,
-}: {
-  title: string
-  entries: [string, string][]
-  description?: string
-  fromFiles?: string[]
-  toFiles?: string[]
-  footer?: ReactNode
-  mask?: boolean
-}) {
-  return (
-    <Box flexDirection="column">
-      {description ? <Text dimColor>{description}</Text> : null}
-      {fromFiles && fromFiles.length > 0 ? (
-        <Box flexDirection="column">
-          <Text dimColor>From:</Text>
-          {fromFiles.map((file) => (
-            <Text key={file} color="cyan">  {file}</Text>
-          ))}
-        </Box>
-      ) : null}
-      {toFiles && toFiles.length > 0 ? (
-        <Box flexDirection="column">
-          <Text dimColor>To:</Text>
-          {toFiles.map((file) => (
-            <Text key={file} color="cyan">  {file}</Text>
-          ))}
-        </Box>
-      ) : null}
-      <Box flexDirection="column" marginTop={1} borderStyle="round" borderColor="green" paddingX={1}>
-        <Text bold color="green">{title}</Text>
-        <EnvEntries entries={entries} {...(mask ? { mask } : {})} />
-      </Box>
-      {footer ?? null}
-    </Box>
-  )
-}
-
-export async function renderEnvSummary(props: {
-  title: string
-  description?: string
-  env: EnvMap
-  fromFiles?: string[]
-  toFiles?: string[]
-  footer?: ReactNode
-}): Promise<void> {
-  const entries: [string, string][] = Object.entries(props.env).sort(([a], [b]) => a.localeCompare(b)) as [string, string][]
-  const app = render(
-    h(EnvSummary, {
-      title: props.title,
-      entries,
-      mask: true,
-      ...(props.description ? { description: props.description } : {}),
-      ...(props.fromFiles ? { fromFiles: props.fromFiles } : {}),
-      ...(props.toFiles ? { toFiles: props.toFiles } : {}),
-      ...(props.footer ? { footer: props.footer } : {}),
-    }),
-  )
-  app.unmount()
-  await app.waitUntilExit()
-}

package/src/services/claude-settings-env-service.ts

@@ -1,72 +0,0 @@
-import { readFile } from 'node:fs/promises'
-
-import { atomicWriteFile } from '../core/fs.js'
-import {
-  resolveClaudeSettingsLocalPath,
-  resolveClaudeSettingsPath,
-  resolveProjectSettingsLocalPath,
-  resolveProjectSettingsPath,
-} from '../core/paths.js'
-import { envMapSchema, type EnvMap } from '../core/schema.js'
-
-export type ClaudeSettingsSource = {
-  path: string
-  exists: boolean
-  env: EnvMap
-}
-
-export function createClaudeSettingsEnvService({ homeDir, cwd }: { homeDir?: string; cwd?: string } = {}) {
-  const paths = [
-    resolveClaudeSettingsPath(homeDir),
-    resolveClaudeSettingsLocalPath(homeDir),
-    resolveProjectSettingsPath(cwd),
-    resolveProjectSettingsLocalPath(cwd),
-  ]
-
-  async function readOne(path: string): Promise<ClaudeSettingsSource> {
-    try {
-      const content = await readFile(path, 'utf8')
-      const json = JSON.parse(content) as { env?: unknown }
-      return {
-        path,
-        exists: true,
-        env: envMapSchema.parse(json.env ?? {}),
-      }
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        return {
-          path,
-          exists: false,
-          env: envMapSchema.parse({}),
-        }
-      }
-
-      throw error
-    }
-  }
-
-  async function writeOne(path: string, env: EnvMap): Promise<void> {
-    let json: Record<string, unknown> = {}
-
-    try {
-      const content = await readFile(path, 'utf8')
-      json = JSON.parse(content) as Record<string, unknown>
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-        throw error
-      }
-    }
-
-    json.env = envMapSchema.parse(env)
-    await atomicWriteFile(path, `${JSON.stringify(json, null, 2)}\n`)
-  }
-
-  return {
-    read: () => Promise.all(paths.map(readOne)),
-    write: async (sources: Array<{ path: string; env: EnvMap }>) => {
-      for (const { path, env } of sources) {
-        await writeOne(path, env)
-      }
-    },
-  }
-}

package/src/services/history-service.ts

@@ -1,48 +0,0 @@
-import { readdir, readFile } from 'node:fs/promises'
-import { dirname, join } from 'node:path'
-
-import { atomicWriteFile, ensureParentDir } from '../core/fs.js'
-import { resolveHistoryPath } from '../core/paths.js'
-import { historySchema } from '../core/schema.js'
-import type { HistoryRecord } from '../core/schema.js'
-
-function isErrnoException(error: unknown): error is NodeJS.ErrnoException {
-  return error instanceof Error && 'code' in error
-}
-
-export function createHistoryService(globalRoot: string) {
-  return {
-    async write(record: HistoryRecord): Promise<HistoryRecord> {
-      const stored = historySchema.parse(record)
-      const filePath = resolveHistoryPath(globalRoot, stored.timestamp)
-      await ensureParentDir(filePath)
-      await atomicWriteFile(filePath, `${JSON.stringify(stored, null, 2)}\n`)
-      return stored
-    },
-
-    async list(): Promise<HistoryRecord[]> {
-      const dirPath = dirname(resolveHistoryPath(globalRoot, 'placeholder'))
-
-      try {
-        const entries = await readdir(dirPath, { withFileTypes: true })
-        const fileNames = entries
-          .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
-          .map((entry) => entry.name)
-          .sort((a, b) => b.localeCompare(a))
-
-        return Promise.all(
-          fileNames.map(async (fileName) => {
-            const content = await readFile(join(dirPath, fileName), 'utf8')
-            return historySchema.parse(JSON.parse(content))
-          }),
-        )
-      } catch (error) {
-        if (isErrnoException(error) && error.code === 'ENOENT') {
-          return []
-        }
-
-        throw error
-      }
-    },
-  }
-}

package/src/services/preset-service.ts

@@ -1,72 +0,0 @@
-import { readdir, readFile, rm } from 'node:fs/promises'
-import { dirname } from 'node:path'
-
-import { CliError } from '../core/errors.js'
-import { atomicWriteFile } from '../core/fs.js'
-import { resolvePresetPath } from '../core/paths.js'
-import { presetSchema, type Preset } from '../core/schema.js'
-
-type StoredPreset = Preset & { filePath: string }
-
-export function createPresetService(globalRoot: string) {
-  function getPath(name: string): string {
-    return resolvePresetPath(globalRoot, name)
-  }
-
-  return {
-    getPath,
-
-    async write(preset: Preset): Promise<StoredPreset> {
-      const parsed = presetSchema.parse(preset)
-      const filePath = getPath(parsed.name)
-      await atomicWriteFile(filePath, `${JSON.stringify(parsed, null, 2)}\n`)
-      return { ...parsed, filePath }
-    },
-
-    async read(name: string): Promise<StoredPreset> {
-      const filePath = getPath(name)
-
-      try {
-        const content = await readFile(filePath, 'utf8')
-        const preset = presetSchema.parse(JSON.parse(content))
-        return { ...preset, filePath }
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-          throw new CliError(`Preset not found: ${name}`)
-        }
-
-        throw error
-      }
-    },
-
-    async listNames(): Promise<string[]> {
-      const dirPath = dirname(getPath('placeholder'))
-
-      try {
-        const entries = await readdir(dirPath, { withFileTypes: true })
-        return entries
-          .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
-          .map((entry) => entry.name.slice(0, -'.json'.length))
-          .sort()
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-          return []
-        }
-
-        throw error
-      }
-    },
-
-    async remove(name: string): Promise<void> {
-      const filePath = getPath(name)
-
-      try {
-        await rm(filePath)
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-          throw error
-        }
-      }
-    },
-  }
-}