@oneworks/cli 0.1.0-alpha.0

package/src/hooks/plugins/index.ts

@@ -0,0 +1,66 @@
+import type { HookContext, HookInputs, HookOutputs, Plugin } from '@oneworks/hooks'
+
+export const callPluginHook = async <K extends keyof HookInputs>(
+  eventName: K,
+  context: HookContext,
+  input: HookInputs[K],
+  plugins: Partial<Plugin>[] = []
+): Promise<HookOutputs[K]> => {
+  const { logger } = context
+  const filterPlugins = plugins.filter(
+    (
+      item
+    ): item is
+      & {
+        name?: string
+      }
+      & {
+        [k in K]: NonNullable<Plugin[k]>
+      } => !!item && !!item[eventName]
+  )
+
+  // 创建中间件链
+  let index = 0
+
+  const next = async (): Promise<HookOutputs[K]> => {
+    if (index >= filterPlugins.length) {
+      // 如果没有更多插件，返回默认结果
+      return { continue: true }
+    }
+
+    const currentPlugin = filterPlugins[index]
+    const { name = '<anonymous>', [eventName]: hook } = currentPlugin
+
+    // 增加索引，防止重复调用导致死循环或错误逻辑
+    index++
+
+    const withNameLogger = {
+      ...logger,
+      info: logger.info.bind(logger, `[plugin.${name}]`),
+      warn: logger.warn.bind(logger, `[plugin.${name}]`),
+      debug: logger.debug.bind(logger, `[plugin.${name}]`),
+      error: logger.error.bind(logger, `[plugin.${name}]`)
+    }
+    try {
+      return await hook(
+        {
+          ...context,
+          logger: withNameLogger
+        },
+        // @ts-ignore
+        input,
+        next
+      )
+    } catch (e) {
+      if (e instanceof Error) {
+        // 只有第一个插件抛出的错误才需要添加对应的插件名
+        if (!e.name.includes('[plugin.')) {
+          e.name = `${e.name}[plugin.${name}]`
+        }
+      }
+      throw e
+    }
+  }
+
+  return next()
+}

package/src/mem-cli.ts

@@ -0,0 +1,19 @@
+import process from 'node:process'
+
+import { Command } from 'commander'
+
+import { getCliVersion } from '#~/utils.js'
+
+import { registerMemorySubcommands } from './commands/memory'
+
+const program = new Command()
+
+program
+  .name('oneworks mem')
+  .description('Read and write OneWorks channel memory from agent sessions')
+  .version(getCliVersion())
+  .showHelpAfterError()
+
+registerMemorySubcommands(program)
+
+program.parse(process.argv)

package/src/session-cache.ts

@@ -0,0 +1,250 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+
+import type { RunTaskOptions } from '@oneworks/app-runtime'
+import type { AdapterQueryOptions, Cache, TaskDetail } from '@oneworks/types'
+import { migrateProjectHomeSegment, resolveProjectOoPath } from '@oneworks/utils'
+import { getCache, getCachePath, setCache } from '@oneworks/utils/cache'
+
+export type CliOutputFormat = 'text' | 'json' | 'stream-json'
+
+export interface CliSessionResumeRecord {
+  version: 1
+  ctxId: string
+  sessionId: string
+  cwd: string
+  description?: string
+  createdAt: number
+  updatedAt: number
+  resolvedAdapter?: string
+  taskOptions: RunTaskOptions
+  adapterOptions: Omit<AdapterQueryOptions, 'description' | 'onEvent' | 'type'>
+  outputFormat: CliOutputFormat
+}
+
+export interface CliSessionRecord {
+  resume?: CliSessionResumeRecord
+  detail?: TaskDetail
+}
+
+export interface CliSessionControlRecord {
+  signal: 'SIGTERM' | 'SIGKILL'
+  requestedAt: number
+  expiresAt: number
+}
+
+declare module '@oneworks/types' {
+  interface Cache {
+    'cli-session': CliSessionResumeRecord
+    'cli-session-control': CliSessionControlRecord
+    detail: TaskDetail
+  }
+}
+
+const readDirSafe = async (target: string) => {
+  try {
+    return await fs.readdir(target, { withFileTypes: true })
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return []
+    throw error
+  }
+}
+
+const readCacheFileAtPath = async <K extends keyof Cache>(target: string): Promise<Cache[K] | undefined> => {
+  try {
+    const content = await fs.readFile(target, 'utf-8')
+    if (content.trim() === '') return undefined
+    return JSON.parse(content) as Cache[K]
+  } catch (error) {
+    if (
+      (error as NodeJS.ErrnoException).code === 'ENOENT' ||
+      error instanceof SyntaxError
+    ) {
+      return undefined
+    }
+    throw error
+  }
+}
+
+const getCacheFromRoot = async <K extends keyof Cache>(
+  cacheRoot: string,
+  ctxId: string,
+  sessionId: string,
+  key: K
+) => readCacheFileAtPath<K>(path.resolve(cacheRoot, ctxId, sessionId, `${String(key)}.json`))
+
+const resolveCliSessionCacheRoot = (cwd: string) => resolveProjectOoPath(cwd, process.env, 'caches')
+
+const getRecordUpdatedAt = (record: CliSessionRecord) =>
+  record.resume?.updatedAt ??
+    record.detail?.endTime ??
+    record.detail?.startTime ??
+    0
+
+const getRecordCreatedAt = (record: CliSessionRecord) =>
+  record.resume?.createdAt ??
+    record.detail?.startTime ??
+    0
+
+const isSessionDirNameMatch = (value: string, target: string) => value === target || value.startsWith(target)
+
+const normalizeResumeCommandPrefix = (prefix: string | undefined) => {
+  const normalizedPrefix = prefix?.trim()
+  return normalizedPrefix == null || normalizedPrefix === '' ? 'oneworks' : normalizedPrefix
+}
+
+export const formatResumeCommand = (sessionId: string, prefix = process.env.__ONEWORKS_CLI_RESUME_COMMAND_PREFIX__) =>
+  `${normalizeResumeCommandPrefix(prefix)} --resume ${sessionId}`
+export const formatStopCommand = (sessionId: string) => `oneworks stop ${sessionId}`
+export const formatKillCommand = (sessionId: string) => `oneworks kill ${sessionId}`
+export const formatListCommand = (params?: {
+  running?: boolean
+  view?: string
+}) => {
+  const args = ['oneworks', 'list']
+  if (params?.running) args.push('--running')
+  if (params?.view != null && params.view !== '') args.push('--view', params.view)
+  return args.join(' ')
+}
+
+export const resolveCliSessionId = (record: CliSessionRecord) =>
+  record.resume?.sessionId ?? record.detail?.sessionId ?? ''
+
+export const resolveCliSessionCtxId = (record: CliSessionRecord) => record.resume?.ctxId ?? record.detail?.ctxId ?? ''
+
+export const resolveCliSessionAdapter = (record: CliSessionRecord) =>
+  record.resume?.resolvedAdapter ??
+    record.detail?.adapter ??
+    record.resume?.taskOptions.adapter ??
+    ''
+
+export const resolveCliSessionModel = (record: CliSessionRecord) =>
+  record.detail?.model ?? record.resume?.adapterOptions.model ?? ''
+
+export const resolveCliSessionDescription = (record: CliSessionRecord) =>
+  record.detail?.description ?? record.resume?.description ?? ''
+
+export const resolveCliSessionUpdatedAt = (record: CliSessionRecord) => getRecordUpdatedAt(record)
+
+export const listCliSessions = async (cwd: string): Promise<CliSessionRecord[]> => {
+  const sessions: CliSessionRecord[] = []
+  const seen = new Set<string>()
+  await migrateProjectHomeSegment(cwd, process.env, 'caches')
+
+  const cacheRoot = resolveCliSessionCacheRoot(cwd)
+  const ctxEntries = await readDirSafe(cacheRoot)
+
+  for (const ctxEntry of ctxEntries) {
+    if (!ctxEntry.isDirectory()) continue
+
+    const ctxId = ctxEntry.name
+    const sessionEntries = await readDirSafe(path.resolve(cacheRoot, ctxId))
+
+    for (const sessionEntry of sessionEntries) {
+      if (!sessionEntry.isDirectory()) continue
+
+      const sessionId = sessionEntry.name
+      const sessionKey = `${ctxId}\0${sessionId}`
+      if (seen.has(sessionKey)) continue
+
+      const [resume, detail] = await Promise.all([
+        getCacheFromRoot(cacheRoot, ctxId, sessionId, 'cli-session'),
+        getCacheFromRoot(cacheRoot, ctxId, sessionId, 'detail')
+      ])
+
+      if (resume == null && detail == null) continue
+      seen.add(sessionKey)
+      sessions.push({ resume, detail })
+    }
+  }
+
+  return sessions.sort((left, right) => getRecordUpdatedAt(right) - getRecordUpdatedAt(left))
+}
+
+export const resolveCliSession = async (cwd: string, id?: string): Promise<CliSessionRecord> => {
+  const sessions = await listCliSessions(cwd)
+  if (id == null || id.trim() === '') {
+    const latest = [...sessions].sort((left, right) => getRecordCreatedAt(right) - getRecordCreatedAt(left))[0]
+    if (latest != null) return latest
+    throw new Error(`No sessions found. Start a session first or use "${formatListCommand({ view: 'full' })}".`)
+  }
+
+  const normalizedId = id.trim()
+
+  const exactSessionMatch = sessions.find((record) =>
+    (record.resume?.sessionId ?? record.detail?.sessionId) === normalizedId
+  )
+  if (exactSessionMatch != null) return exactSessionMatch
+
+  const exactCtxMatches = sessions.filter((record) => (record.resume?.ctxId ?? record.detail?.ctxId) === normalizedId)
+  if (exactCtxMatches.length === 1) return exactCtxMatches[0]!
+  if (exactCtxMatches.length > 1) {
+    throw new Error(`Session id "${id}" matches multiple task contexts. Use a session id instead.`)
+  }
+
+  const prefixMatches = sessions.filter((record) => {
+    const sessionId = record.resume?.sessionId ?? record.detail?.sessionId
+    const ctxId = record.resume?.ctxId ?? record.detail?.ctxId
+    return (
+      (sessionId != null && isSessionDirNameMatch(sessionId, normalizedId)) ||
+      (ctxId != null && isSessionDirNameMatch(ctxId, normalizedId))
+    )
+  })
+
+  if (prefixMatches.length === 1) return prefixMatches[0]!
+  if (prefixMatches.length > 1) {
+    const candidates = prefixMatches
+      .map(resolveCliSessionId)
+      .filter((value): value is string => value != null)
+      .slice(0, 5)
+      .join(', ')
+    throw new Error(`Session id "${id}" is ambiguous: ${candidates}`)
+  }
+
+  throw new Error(
+    `Session "${id}" not found. Use "${formatListCommand({ view: 'full' })}" to inspect available sessions.`
+  )
+}
+
+export const writeCliSessionRecord = async (
+  cwd: string,
+  ctxId: string,
+  sessionId: string,
+  record: CliSessionRecord
+) => {
+  await Promise.all([
+    record.resume == null
+      ? Promise.resolve()
+      : setCache(cwd, ctxId, sessionId, 'cli-session', record.resume),
+    record.detail == null
+      ? Promise.resolve()
+      : setCache(cwd, ctxId, sessionId, 'detail', record.detail)
+  ])
+}
+
+export const readCliSessionControl = (
+  cwd: string,
+  ctxId: string,
+  sessionId: string
+) => getCache(cwd, ctxId, sessionId, 'cli-session-control')
+
+export const writeCliSessionControl = (
+  cwd: string,
+  ctxId: string,
+  sessionId: string,
+  control: CliSessionControlRecord
+) => setCache(cwd, ctxId, sessionId, 'cli-session-control', control)
+
+export const clearCliSessionControl = async (
+  cwd: string,
+  ctxId: string,
+  sessionId: string
+) => {
+  await fs.rm(getCachePath(cwd, ctxId, sessionId, 'cli-session-control'), { force: true })
+}
+
+export const isCliSessionStopActive = (
+  control: CliSessionControlRecord | undefined,
+  endedAt: number
+) => control != null && endedAt <= control.expiresAt

package/src/session-permission-cache.ts

@@ -0,0 +1,40 @@
+import fs from 'node:fs/promises'
+
+import type { AskUserQuestionParams, SessionPermissionMode } from '@oneworks/types'
+import { getCache, getCachePath, setCache } from '@oneworks/utils/cache'
+
+export interface CliSessionPermissionRecoveryRecord {
+  version: 1
+  sessionId: string
+  adapter?: string
+  permissionMode?: SessionPermissionMode
+  subjectKeys: string[]
+  payload: AskUserQuestionParams
+}
+
+declare module '@oneworks/types' {
+  interface Cache {
+    'cli-session-permission-recovery': CliSessionPermissionRecoveryRecord
+  }
+}
+
+export const readCliSessionPermissionRecovery = (
+  cwd: string,
+  ctxId: string,
+  sessionId: string
+) => getCache(cwd, ctxId, sessionId, 'cli-session-permission-recovery')
+
+export const writeCliSessionPermissionRecovery = (
+  cwd: string,
+  ctxId: string,
+  sessionId: string,
+  record: CliSessionPermissionRecoveryRecord
+) => setCache(cwd, ctxId, sessionId, 'cli-session-permission-recovery', record)
+
+export const clearCliSessionPermissionRecovery = async (
+  cwd: string,
+  ctxId: string,
+  sessionId: string
+) => {
+  await fs.rm(getCachePath(cwd, ctxId, sessionId, 'cli-session-permission-recovery'), { force: true })
+}

package/src/utils.ts

@@ -0,0 +1,25 @@
+let packageJson: Record<string, any> | undefined
+
+function getPackageJson() {
+  if (!packageJson) {
+    try {
+      // eslint-disable-next-line ts/no-require-imports
+      packageJson = require('@oneworks/cli/package.json')
+    } catch {
+      packageJson = {}
+    }
+  }
+  return packageJson!
+}
+
+export function getPackageConfig(key: string, defaultValue = ''): string {
+  return getPackageJson()[key] ?? defaultValue
+}
+
+export function getCliVersion() {
+  return getPackageConfig('version', '0.0.0')
+}
+
+export function getCliDescription() {
+  return getPackageConfig('description', 'One Works CLI')
+}

package/src/workspace.ts

@@ -0,0 +1,12 @@
+import process from 'node:process'
+
+import { resolveProjectWorkspaceFolder } from '@oneworks/utils'
+
+export const resolveCliWorkspaceCwd = (
+  cwd: string = process.cwd(),
+  env: NodeJS.ProcessEnv = process.env
+) => {
+  const workspaceCwd = resolveProjectWorkspaceFolder(cwd, env)
+  env.__ONEWORKS_PROJECT_WORKSPACE_FOLDER__ = workspaceCwd
+  return workspaceCwd
+}