@lkangd/cc-env 1.0.0

package/src/core/spawn.ts

@@ -0,0 +1,36 @@
+import spawn from 'cross-spawn'
+
+import { CliError } from './errors.js'
+
+export function spawnCommand(
+  command: string,
+  args: string[],
+  env: NodeJS.ProcessEnv,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      env,
+      stdio: 'inherit',
+    })
+
+    child.once('error', reject)
+    child.once('close', (exitCode: number | null, signal: NodeJS.Signals | null) => {
+      if (signal) {
+        reject(new CliError(`Command terminated by signal ${signal}`))
+        return
+      }
+
+      if (exitCode === null) {
+        reject(new CliError('Command terminated without an exit code'))
+        return
+      }
+
+      if (exitCode !== 0) {
+        reject(new CliError(`Command exited with code ${exitCode}`, exitCode))
+        return
+      }
+
+      resolve()
+    })
+  })
+}

package/src/flows/init-flow.ts

@@ -0,0 +1,61 @@
+export type InitFlowStep = 'keys' | 'confirm' | 'done'
+
+export type InitFlowState = {
+  step: InitFlowStep
+  availableKeys: string[]
+  requiredKeys: string[]
+  selectedKeys: string[]
+}
+
+export type InitFlowAction =
+  | { type: 'toggle-key'; key: string }
+  | { type: 'continue' }
+  | { type: 'confirm' }
+
+export function createInitFlowState(
+  availableKeys: string[],
+  requiredKeys: string[],
+): InitFlowState {
+  return {
+    step: 'keys',
+    availableKeys,
+    requiredKeys,
+    selectedKeys: requiredKeys,
+  }
+}
+
+export function advanceInitFlow(
+  state: InitFlowState,
+  action: InitFlowAction,
+): InitFlowState {
+  if (state.step === 'keys' && action.type === 'toggle-key') {
+    if (state.requiredKeys.includes(action.key)) {
+      return state
+    }
+
+    const selectedKeys = state.selectedKeys.includes(action.key)
+      ? state.selectedKeys.filter((key) => key !== action.key)
+      : [...state.selectedKeys, action.key]
+
+    return {
+      ...state,
+      selectedKeys,
+    }
+  }
+
+  if (state.step === 'keys' && action.type === 'continue') {
+    return {
+      ...state,
+      step: 'confirm',
+    }
+  }
+
+  if (state.step === 'confirm' && action.type === 'confirm') {
+    return {
+      ...state,
+      step: 'done',
+    }
+  }
+
+  return state
+}

package/src/flows/preset-create-flow.ts

@@ -0,0 +1,129 @@
+import type { EnvMap } from '../core/schema.js'
+
+export type PresetCreateSource = 'file' | 'manual'
+export type PresetCreateDestination = 'global' | 'project'
+
+export type PresetCreateStep =
+  | 'source'
+  | 'filePath'
+  | 'keys'
+  | 'manualInput'
+  | 'name'
+  | 'destination'
+  | 'confirm'
+  | 'done'
+
+export type PresetCreateFlowState = {
+  step: PresetCreateStep
+  source?: PresetCreateSource
+  filePath?: string
+  env: EnvMap
+  allKeys: string[]
+  selectedKeys: string[]
+  presetName: string
+  destination?: PresetCreateDestination
+  error?: string | undefined
+}
+
+export type PresetCreateFlowResult = Pick<
+  PresetCreateFlowState,
+  'source' | 'env' | 'selectedKeys' | 'presetName' | 'destination'
+> & {
+  filePath?: string | undefined
+}
+
+export type PresetCreateFlowAction =
+  | { type: 'select-source'; source: PresetCreateSource }
+  | { type: 'set-file-path'; filePath: string }
+  | { type: 'set-error'; error: string }
+  | { type: 'select-keys'; keys: string[]; env: EnvMap }
+  | { type: 'add-manual-pair'; key: string; value: string }
+  | { type: 'finish-manual-input' }
+  | { type: 'set-name'; name: string }
+  | { type: 'select-destination'; destination: PresetCreateDestination }
+  | { type: 'confirm' }
+
+export function createPresetCreateFlowState(): PresetCreateFlowState {
+  return {
+    step: 'source',
+    env: {},
+    allKeys: [],
+    selectedKeys: [],
+    presetName: '',
+  }
+}
+
+export function advancePresetCreateFlow(
+  state: PresetCreateFlowState,
+  action: PresetCreateFlowAction,
+): PresetCreateFlowState {
+  switch (state.step) {
+    case 'source':
+      if (action.type !== 'select-source') return state
+      return {
+        ...state,
+        step: action.source === 'file' ? 'filePath' : 'manualInput',
+        source: action.source,
+      }
+
+    case 'filePath':
+      if (action.type === 'set-error') {
+        return { ...state, error: action.error }
+      }
+      if (action.type !== 'set-file-path') return state
+      return {
+        ...state,
+        step: 'keys',
+        filePath: action.filePath,
+        error: undefined,
+      }
+
+    case 'keys':
+      if (action.type !== 'select-keys') return state
+      return {
+        ...state,
+        step: 'name',
+        selectedKeys: action.keys,
+        env: action.env,
+      }
+
+    case 'manualInput':
+      if (action.type === 'add-manual-pair') {
+        const hasKey = state.selectedKeys.includes(action.key)
+        return {
+          ...state,
+          env: { ...state.env, [action.key]: action.value },
+          selectedKeys: hasKey ? state.selectedKeys : [...state.selectedKeys, action.key],
+          error: undefined,
+        }
+      }
+      if (action.type === 'set-error') {
+        return { ...state, error: action.error }
+      }
+      if (action.type !== 'finish-manual-input') return state
+      return { ...state, step: 'name' }
+
+    case 'name':
+      if (action.type !== 'set-name') return state
+      return {
+        ...state,
+        step: 'destination',
+        presetName: action.name,
+      }
+
+    case 'destination':
+      if (action.type !== 'select-destination') return state
+      return {
+        ...state,
+        step: 'confirm',
+        destination: action.destination,
+      }
+
+    case 'confirm':
+      if (action.type !== 'confirm') return state
+      return { ...state, step: 'done' }
+
+    case 'done':
+      return state
+  }
+}

package/src/flows/restore-flow.ts

@@ -0,0 +1,144 @@
+import type { HistoryRecord } from '../core/schema.js'
+
+export type RestoreFlowStep = 'record' | 'target' | 'confirm' | 'done'
+
+type BaseRestoreFlowState = {
+  records: HistoryRecord[]
+  selectedTimestamp?: string
+}
+
+export type RestoreFlowState =
+  | ({ step: 'record' } & BaseRestoreFlowState)
+  | ({ step: 'target'; selectedTimestamp: string } & BaseRestoreFlowState)
+  | ({ step: 'confirm'; selectedTimestamp: string } & BaseRestoreFlowState & (
+      | {
+          targetType: 'settings'
+        }
+      | {
+          targetType: 'preset'
+          targetName: string
+        }
+    ))
+  | ({ step: 'done'; selectedTimestamp: string } & BaseRestoreFlowState & (
+      | {
+          targetType: 'settings'
+        }
+      | {
+          targetType: 'preset'
+          targetName: string
+        }
+    ))
+
+export type RestoreFlowAction =
+  | {
+      type: 'select-record'
+      timestamp: string
+    }
+  | {
+      type: 'select-target'
+      targetType: 'settings' | 'preset'
+      targetName?: string
+    }
+  | {
+      type: 'confirm'
+    }
+
+export function createRestoreFlowState(records: HistoryRecord[]): RestoreFlowState {
+  return {
+    step: 'record',
+    records,
+  }
+}
+
+export function advanceRestoreFlow(
+  state: RestoreFlowState,
+  action: RestoreFlowAction,
+): RestoreFlowState {
+  switch (state.step) {
+    case 'record': {
+      if (action.type !== 'select-record') {
+        return state
+      }
+
+      const selectedRecord = state.records.find(
+        (record) => record.timestamp === action.timestamp,
+      )
+
+      if (!selectedRecord) {
+        return state
+      }
+
+      if (selectedRecord.action === 'init') {
+        return {
+          ...state,
+          step: 'confirm',
+          selectedTimestamp: action.timestamp,
+        } as RestoreFlowState
+      }
+
+      return {
+        ...state,
+        step: 'target',
+        selectedTimestamp: action.timestamp,
+      }
+    }
+
+    case 'target':
+      if (action.type !== 'select-target' || !state.selectedTimestamp) {
+        return state
+      }
+
+      if (action.targetType === 'preset' && !action.targetName) {
+        return state
+      }
+
+      if (action.targetType === 'settings') {
+        return {
+          ...state,
+          step: 'confirm',
+          targetType: 'settings',
+        }
+      }
+
+      const targetName = action.targetName as string
+
+      return {
+        ...state,
+        step: 'confirm',
+        targetType: 'preset',
+        targetName,
+      }
+
+    case 'confirm':
+      if (action.type !== 'confirm' || !state.selectedTimestamp) {
+        return state
+      }
+
+      const selectedRecord = state.records.find(
+        (record) => record.timestamp === state.selectedTimestamp,
+      )
+
+      if (selectedRecord?.action === 'init') {
+        return {
+          ...state,
+          step: 'done',
+        } as RestoreFlowState
+      }
+
+      if (!state.targetType) {
+        return state
+      }
+
+      if (state.targetType === 'preset' && !state.targetName) {
+        return state
+      }
+
+      return {
+        ...state,
+        step: 'done',
+      }
+
+    case 'done':
+      return state
+  }
+}

package/src/ink/init-app.tsx

@@ -0,0 +1,110 @@
+import React, { useEffect, useState } from 'react'
+import { Box, Text, useApp, useInput } from 'ink'
+
+import {
+  advanceInitFlow,
+  createInitFlowState,
+} from '../flows/init-flow.js'
+
+export function InitApp({
+  keys = [],
+  requiredKeys = [],
+  sourceFiles = [],
+  onSubmit,
+}: {
+  keys?: string[]
+  requiredKeys?: string[]
+  sourceFiles?: string[]
+  onSubmit?: (result: { confirmed: boolean; selectedKeys: string[] }) => void
+}) {
+  const { exit } = useApp()
+  const [cursor, setCursor] = useState(0)
+  const [flowState, setFlowState] = useState(() =>
+    createInitFlowState(keys, requiredKeys),
+  )
+
+  useEffect(() => {
+    if (!onSubmit) {
+      return
+    }
+
+    if (keys.length === 0) {
+      onSubmit({ confirmed: false, selectedKeys: [] })
+      exit()
+    }
+  }, [exit, keys.length, onSubmit])
+
+  useInput((input, key) => {
+    if (!onSubmit) {
+      return
+    }
+
+    if (key.upArrow || input === 'k') {
+      setCursor((c) => Math.max(0, c - 1))
+      return
+    }
+
+    if (key.downArrow || input === 'j') {
+      setCursor((c) => Math.min(keys.length - 1, c + 1))
+      return
+    }
+
+    if (input === ' ') {
+      const targetKey = keys[cursor]
+      if (targetKey) {
+        setFlowState((prev) =>
+          advanceInitFlow(prev, { type: 'toggle-key', key: targetKey }),
+        )
+      }
+      return
+    }
+
+    if (key.return) {
+      onSubmit({ confirmed: true, selectedKeys: flowState.selectedKeys })
+      exit()
+      return
+    }
+
+    if (key.escape || input.toLowerCase() === 'q') {
+      onSubmit({ confirmed: false, selectedKeys: [] })
+      exit()
+    }
+  })
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Select env keys to migrate into managed shell config</Text>
+      {sourceFiles.length > 0 ? (
+        <Box flexDirection="column">
+          <Text dimColor>Source:</Text>
+          {sourceFiles.map((file) => (
+            <Text key={file} color="cyan">  {file}</Text>
+          ))}
+        </Box>
+      ) : null}
+      <Text dimColor>↑/k ↓/j navigate · space toggle · enter confirm · q cancel</Text>
+      <Box flexDirection="column" marginTop={1}>
+        {keys.map((key, i) => {
+          const isRequired = requiredKeys.includes(key)
+          const isSelected = flowState.selectedKeys.includes(key)
+          const isCursor = i === cursor
+          const checkbox = isSelected ? '[x]' : '[ ]'
+
+          return (
+            <Box key={key}>
+              <Text>{isCursor ? '❯ ' : '  '}</Text>
+              <Text color={isSelected ? 'green' : ''}>{checkbox}</Text>
+              <Text> {key}</Text>
+              {isRequired ? <Text dimColor> (required)</Text> : null}
+            </Box>
+          )
+        })}
+      </Box>
+      <Box marginTop={1}>
+        <Text dimColor>
+          {flowState.selectedKeys.length} of {keys.length} selected
+        </Text>
+      </Box>
+    </Box>
+  )
+}