18 代码走读实录

const onSubmitCommand = async (inputText: string) => {
  if (!inputText) {
    return
  }
  const terminal = terminalRef.value.terminal
  await doCommandExecute(inputText, terminal)
}

const userStore = useUserStore()
const { loginUser } = storeToRefs(userStore)

onMounted(async () => {
  await userStore.getAndSetLoginUser()
  // remember 自动登录路径同样要初始化云同步：漏掉的类型既不会从云端拉取，
  // 该端下一次改动还会把云端已有数据整包覆盖掉（#24 #25）
  if (userStore.loginUser?.id) {
    await initAllCloudSync()
  }
})

const doSubmitCommand = async () => {
  // 反向搜索模式下，回车表示接受当前匹配并退出搜索，不直接执行
  if (isSearchMode.value) {
    acceptSearchResult()
    return
  }
  isRunning.value = true
  setHint('')
  try {
    let inputText = inputCommand.value.text
    // 执行某条历史命令
    if (inputText.startsWith('!')) {
      const commandIndex = Number(inputText.substring(1))
      if (isNaN(commandIndex) || commandIndex < 1 || commandIndex > commandList.value.length) {
        terminal.writeTextErrorResult('无效的历史命令序号')
        inputCommand.value = { ...initCommand }
        return
      }
      const command = commandList.value[commandIndex - 1]
      if (command) {
        inputText = command.text
      }
    }
    const newCommand: CommandOutputType = {
      text: inputText,
      type: 'command',
      resultList: [],
    }
    // 记录当前命令，便于写入结果
    currentNewCommand = newCommand
    await props.onSubmitCommand?.(inputText)
    outputList.value.push(newCommand)
    if (inputText) {
      commandList.value.push(newCommand)
      commandHistoryPos.value = commandList.value.length
    }
    inputCommand.value = { ...initCommand }
    activeKeys.value.push(outputList.value.length - 1)
    setTimeout(() => {
      terminalRef.value.scrollTop = terminalRef.value.scrollHeight
    }, 50)
  } finally {
    // 无论命令是否抛错，都复位输入框，避免永久禁用
    isRunning.value = false
  }
}

export const doCommandExecute = async (
  text: string,
  terminal: TerminalType,
  parentCommand?: CommandType,
  depth = 0,
) => {
  // 防止子命令无限递归
  if (depth > 10) {
    terminal.writeTextErrorResult('命令层级过深')
    return
  }
  // 去除命令首尾空格
  text = text.trim()
  if (!text) {
    return
  }
  // 解析文本，得到命令
  const command = getCommand(text, parentCommand)
  if (!command) {
    // 自定义命令回退：输入的名称匹配用户自定义的快捷命令时，执行其对应文本 (#73)
    const token = (text.split(' ', 1)[0] ?? '').toLowerCase()
    const customText = useCustomCommandStore().getCustom(token)
    if (customText) {
      // 保留自定义命令名之后追加的参数，如 g google.com => goto google.com
      const restArgs = text.slice(token.length).trim()
      await doCommandExecute(
        restArgs ? `${customText} ${restArgs}` : customText,
        terminal,
        undefined,
        depth + 1,
      )
      return
    }
    terminal.writeTextErrorResult('找不到命令')
    return
  }
  // 解析参数（需传递不同的解析规则）
  const parsedOptions = doParse(text, command.options)
  const { _ } = parsedOptions
  // 有子命令，执行
  if (_.length > 0 && command.subCommands && Object.keys(command.subCommands).length > 0) {
    // 把子命令当做新命令解析，user login xxx => login xxx
    const spaceIndex = text.indexOf(' ')
    const subText = spaceIndex > -1 ? text.substring(spaceIndex + 1) : ''
    await doCommandExecute(subText, terminal, command, depth + 1)
    return
  }
  // 执行命令
  await doAction(command, parsedOptions, terminal, parentCommand)
}

const doParse = (
  text: string,
  commandOptions: CommandOptionType[],
): getoptsNamespace.ParsedOptions => {
  // 过滤掉关键词，支持多个连续空格
  const args: string[] = text.split(/\s+/).slice(1).filter(Boolean)
  // 转换
  const options: getoptsNamespace.Options = {
    alias: {},
    default: {},
    string: [],
    boolean: [],
  }
  commandOptions.forEach((commandOption) => {
    const { alias, key, type, defaultValue } = commandOption
    if (alias && options.alias) {
      options.alias[key] = alias
    }
    options[type === 'boolean' ? 'boolean' : 'string']?.push(key)
    // 默认值为空字符串（如 curl 的 maxLength）时也应生效，故用 !== undefined 判断
    if (defaultValue !== undefined && options.default) {
      options.default[key] = defaultValue
    }
  })
  const parsedOptions = getopts(args, options)
  return parsedOptions
}

const validateRequiredParams = (
  command: CommandType,
  options: getoptsNamespace.ParsedOptions,
  terminal: TerminalType,
): boolean => {
  if (command.subCommands && Object.keys(command.subCommands).length > 0) {
    return true
  }
  const requiredParams = command.params?.filter((p) => p.required) ?? []
  if (requiredParams.length === 0) {
    return true
  }
  if (options._.length >= requiredParams.length) {
    return true
  }
  const missing = requiredParams.map((p) => p.key).join('、')
  terminal.writeTextErrorResult(`缺少参数：${missing}，请使用 ${command.func} --help 查看用法`)
  return false
}

  async action(options, terminal) {
    const { _ } = options
    const city = _.join(' ')
    if (!city) {
      terminal.writeTextResult('用法：weather <城市名>\n示例：weather 北京')
      return
    }
    try {
      const json = await myAxios.get<string>('/weather', { params: { city } })
      if (json.code !== 0 || !json.data) {
        throw new Error(json.message || '天气服务返回异常')
      }
      // 浏览器 User-Agent 下 wttr.in 会返回 HTML 页面，需从 term-container 中提取纯文本
      const text = json.data
      const containerMatch = text.match(/<div class="term-container">([\s\S]*?)<\/div>/)
      const cleanText = containerMatch
        ? containerMatch[1]!.replace(/<[^>]+>/g, '').trim()
        : text.trim()
      terminal.writeTextResult(decodeHtmlEntities(cleanText) || '暂无天气数据')
    } catch (e) {
      terminal.writeTextErrorResult(`天气查询失败：${errMsg(e)}，请检查城市名或网络`)
    }
  }

export interface Migration {
  id: string
  statements: string[]
}

/** 与被 sequelize 定义的表保持一致的 DDL */
export const MIGRATIONS: Migration[] = [
  {
    id: '0001_init_user_and_user_data',
    statements: [
      `CREATE TABLE IF NOT EXISTS \`user\` (
        \`id\` BIGINT NOT NULL AUTO_INCREMENT,
        \`username\` VARCHAR(255) NOT NULL,
        \`password\` VARCHAR(255) NOT NULL,
        \`email\` VARCHAR(255) NULL,
        \`status\` INT NOT NULL DEFAULT 0,
        \`createTime\` DATETIME NULL,
        \`updateTime\` DATETIME NULL,
        \`isDelete\` INT NOT NULL DEFAULT 0,
        PRIMARY KEY (\`id\`),
        UNIQUE KEY \`user_username_unique\` (\`username\`),
        UNIQUE KEY \`user_email_unique\` (\`email\`)
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
      `CREATE TABLE IF NOT EXISTS \`user_data\` (
        \`id\` BIGINT NOT NULL AUTO_INCREMENT,
        \`userId\` BIGINT NOT NULL,
        \`type\` VARCHAR(32) NOT NULL,
        \`content\` MEDIUMTEXT NULL,
        PRIMARY KEY (\`id\`),
        UNIQUE KEY \`user_data_userId_type_unique\` (\`userId\`, \`type\`)
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
    ],
  },
]

/** 记录已应用迁移的水位表 */
const MIGRATIONS_TABLE = 'schema_migrations'

export function migrationsTableDdl(): string {
  return `CREATE TABLE IF NOT EXISTS \`${MIGRATIONS_TABLE}\` (
    \`id\` VARCHAR(64) NOT NULL,
    \`appliedAt\` DATETIME NOT NULL,
    PRIMARY KEY (\`id\`)
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`
}

/** 只要能被迁移器调用到的最小连接面，便于单测替换 */
export interface MigrationRunner {
  query: (sql: string) => Promise<unknown>
}

export async function runMigrations(
  runner: MigrationRunner,
  migrations: Migration[] = MIGRATIONS,
): Promise<MigrationResult> {
  await runner.query(migrationsTableDdl())
  const done = await appliedIds(runner)
  const applied: string[] = []
  const skipped: string[] = []
  for (const migration of [...migrations].sort((a, b) => a.id.localeCompare(b.id))) {
    if (done.has(migration.id)) {
      skipped.push(migration.id)
      continue
    }
    for (const statement of migration.statements) await runner.query(statement)
    await runner.query(
      `INSERT INTO \`${MIGRATIONS_TABLE}\` (\`id\`, \`appliedAt\`) VALUES (${escapeSql(
        migration.id,
      )}, CURRENT_TIMESTAMP)`,
    )
    applied.push(migration.id)
  }
  return { applied, skipped }
}

/** 迁移 id 来自代码常量，这里只做字面量转义，不接受外部输入 */
function escapeSql(value: string): string {
  return `'${value.replace(/[\\']/g, '\\$&')}'`
}

export default defineNitroPlugin(async () => {
  try {
    const sequelize = useDb()
    const runner: MigrationRunner = {
      async query(sql: string) {
        const [rows] = await sequelize.query(sql)
        return rows
      },
    }
    const { applied, skipped } = await runMigrations(runner)
    setSchemaStatus(true)
    if (applied.length) console.log('[migrate] 已应用迁移：', applied.join(', '))
    else console.log('[migrate] 数据库结构已是最新（跳过 %d 条）', skipped.length)
  } catch (e: unknown) {
    const message = e instanceof Error ? e.message : String(e)
    setSchemaStatus(false, message)
    console.error('[migrate] 数据库迁移失败，注册/登录可能不可用：', message)
  }
})

export function useCloudSync(type: string, options: CloudSyncOptions): CloudSync {
  let syncTimer: ReturnType<typeof setTimeout> | undefined
  let syncUserId: string | number | null = null
  let unsubscribe: (() => void) | null = null
  // 正在写入远端数据：此期间 store 变更不再触发上传，避免合并引发回环
  let applyingRemote = false

  /** 防抖到点后执行：先合并云端，再上传合并结果 */
  async function flush() {
    let cloudRaw: string | null = null
    try {
      cloudRaw = await fetchCloudRaw()
      if (cloudRaw) applyCloud(cloudRaw)
    } catch (e) {
      // 拉取失败时仍上传本地数据，不因网络抖动丢掉本次变更
      console.error(`${type} 同步前拉取失败`, errMsg(e))
    }
    const content = JSON.stringify(options.serialize())
    // 云端已是最新：跳过上传，同时切断「合并 -> 订阅 -> 再同步」的回环
    if (content === cloudRaw) return
    try {
      await myAxios.post('/data/sync', { type, content })
    } catch (e) {
      console.error(`${type} 同步失败`, e)
    }
  }

  /** 同步到云端（防抖，未登录时跳过） */
  function syncToCloud() {
    if (!getUserId() || applyingRemote) return
    if (syncTimer) clearTimeout(syncTimer)
    syncTimer = setTimeout(() => void flush(), options.debounce ?? 800)
  }

export function mergeKeyed<T extends Revivable>(
  cloudItems: T[],
  localItems: T[],
  keyOf: (item: T) => string,
  cloudDeleted: Record<string, number> = {},
  localDeleted: Record<string, number> = {},
  now = Date.now(),
): MergeResult<T> {
  const deleted = pruneTombstones(mergeTombstones(cloudDeleted, localDeleted), now)
  const byKey = new Map<string, T>()
  for (const item of [...cloudItems, ...localItems]) {
    const key = keyOf(item)
    const exists = byKey.get(key)
    if (!exists || (item.updateTime ?? 0) >= (exists.updateTime ?? 0)) byKey.set(key, item)
  }
  const items: T[] = []
  for (const [key, item] of byKey) {
    const deletedAt = deleted[key]
    // 删除时间不早于条目修改时间 -> 视为已删除；条目改得更晚则视为「删掉后又重建」
    if (deletedAt !== undefined && (item.updateTime ?? 0) <= deletedAt) continue
    items.push(item)
  }
  return { items, deleted }
}

function parseCloud(data: unknown): TodoCloudShape {
  if (Array.isArray(data)) return { items: data as TaskType[], deleted: {} }
  if (data && typeof data === 'object') {
    const obj = data as { items?: unknown; deleted?: unknown }
    return {
      items: Array.isArray(obj.items) ? (obj.items as TaskType[]) : [],
      deleted:
        obj.deleted && typeof obj.deleted === 'object'
          ? (obj.deleted as Record<string, number>)
          : {},
    }
  }
  return { items: [], deleted: {} }
}

const cloudSync = useCloudSync('todo', {
  serialize: () => ({
    items: getStore().taskList,
    deleted: pruneTombstones(getStore().deleted),
  }),
  merge: (data) => {
    const store = getStore()
    const cloud = parseCloud(data)
    const { items, deleted } = mergeKeyed<TaskType>(
      cloud.items,
      store.taskList,
      (task) => task.id,
      cloud.deleted,
      store.deleted,
    )
    store.taskList = items
    store.deleted = deleted
  },
})