@lkangd/cc-env 1.0.0

package/src/ink/restore-app.tsx

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

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

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

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

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

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