@oneworks/cli 0.1.0-alpha.0

package/src/commands/config/read-state.ts

@@ -0,0 +1,56 @@
+import process from 'node:process'
+
+import {
+  getConfigSectionValueAtPath,
+  hasConfigSectionValue,
+  parseConfigSectionPath,
+  resolveConfigSectionPath
+} from '@oneworks/config'
+
+import { loadCommandState, resolveSourceConfig, resolveSourceSections } from './shared'
+import type { ConfigReadSource, LoadedConfigCommandState } from './shared'
+
+export interface ResolvedReadState {
+  cwd: string
+  source: ConfigReadSource
+  state: LoadedConfigCommandState
+  resolvedPath?: ReturnType<typeof resolveConfigSectionPath>
+  value: unknown
+}
+
+export const resolveReadState = async (
+  pathInput: string | undefined,
+  sourceInput: ConfigReadSource | undefined
+): Promise<ResolvedReadState> => {
+  const cwd = process.cwd()
+  const source = sourceInput ?? 'merged'
+  const state = await loadCommandState(cwd)
+  const sourceConfig = resolveSourceConfig(state, source)
+
+  if (source !== 'merged' && sourceConfig == null) {
+    throw new Error(`No ${source} config found for workspace "${cwd}".`)
+  }
+
+  if (pathInput == null || pathInput.trim() === '') {
+    return {
+      cwd,
+      source,
+      state,
+      value: resolveSourceSections(state, source)
+    }
+  }
+
+  const resolvedPath = resolveConfigSectionPath(parseConfigSectionPath(pathInput))
+  const result = getConfigSectionValueAtPath(resolveSourceSections(state, source), resolvedPath)
+  if (!result.exists || (resolvedPath.sectionPath.length === 0 && !hasConfigSectionValue(result.value))) {
+    throw new Error(`Config path "${resolvedPath.normalizedPath}" was not found in ${source} config.`)
+  }
+
+  return {
+    cwd,
+    source,
+    state,
+    resolvedPath,
+    value: result.value
+  }
+}

package/src/commands/config/section-state.ts

@@ -0,0 +1,109 @@
+import { CONFIG_SECTION_KEYS, hasConfigSectionValue } from '@oneworks/config'
+import type { ConfigSectionKey, ConfigSections } from '@oneworks/config'
+
+import { CONFIG_READ_SOURCES } from './shared'
+import type { ConfigListSource, LoadedConfigCommandState } from './shared'
+
+export const resolveListOutput = (
+  state: LoadedConfigCommandState,
+  source: ConfigListSource
+) => {
+  if (source !== 'all') {
+    return Object.fromEntries(
+      CONFIG_SECTION_KEYS.map(section => [
+        section,
+        hasConfigSectionValue(state.sections[source][section])
+      ])
+    )
+  }
+
+  const sources = source === 'all' ? CONFIG_READ_SOURCES : [source]
+
+  return Object.fromEntries(
+    CONFIG_SECTION_KEYS.map((section) => [
+      section,
+      Object.fromEntries(
+        sources.map(currentSource => [
+          currentSource,
+          hasConfigSectionValue(state.sections[currentSource][section])
+        ])
+      )
+    ])
+  )
+}
+
+export const resolveTextListRows = (
+  state: LoadedConfigCommandState,
+  source: ConfigListSource
+) => {
+  if (source !== 'all') {
+    return CONFIG_SECTION_KEYS.map((section) => ({
+      Section: section,
+      Present: hasConfigSectionValue(state.sections[source][section]) ? 'yes' : ''
+    }))
+  }
+
+  const sources = source === 'all' ? CONFIG_READ_SOURCES : [source]
+
+  return CONFIG_SECTION_KEYS.map((section) => (
+    Object.fromEntries([
+      ['Section', section],
+      ...sources.map(currentSource => [
+        currentSource[0]!.toUpperCase() + currentSource.slice(1),
+        hasConfigSectionValue(state.sections[currentSource][section]) ? 'yes' : ''
+      ])
+    ])
+  ))
+}
+
+export const resolveClearedSectionValue = (section: ConfigSectionKey): ConfigSections[ConfigSectionKey] => {
+  switch (section) {
+    case 'general':
+      return {
+        baseDir: undefined,
+        disableGlobalConfig: undefined,
+        effort: undefined,
+        defaultAdapter: undefined,
+        defaultModelService: undefined,
+        defaultModel: undefined,
+        recommendedModels: undefined,
+        interfaceLanguage: undefined,
+        modelLanguage: undefined,
+        announcements: undefined,
+        permissions: undefined,
+        env: undefined,
+        notifications: undefined,
+        messageLinks: undefined,
+        skills: undefined,
+        skillsMeta: undefined,
+        skillRegistries: undefined,
+        webAuth: undefined,
+        shortcuts: undefined
+      }
+    case 'plugins':
+      return {
+        plugins: undefined,
+        marketplaces: undefined
+      }
+    case 'mcp':
+      return {
+        mcpServers: undefined,
+        defaultIncludeMcpServers: undefined,
+        defaultExcludeMcpServers: undefined,
+        noDefaultOneworksMcpServer: undefined
+      }
+    case 'conversation':
+    case 'models':
+    case 'modelServices':
+    case 'workspaces':
+    case 'channels':
+    case 'adapters':
+    case 'appearance':
+    case 'desktop':
+    case 'auth':
+    case 'shortcuts':
+    case 'experiments':
+    case 'diagnostics':
+      return {}
+  }
+}

package/src/commands/config/shared.ts

@@ -0,0 +1,195 @@
+import process from 'node:process'
+
+import {
+  buildConfigJsonVariables,
+  buildConfigSections,
+  formatConfigValueAsYaml,
+  loadConfigState,
+  resolveConfigSectionWriteError
+} from '@oneworks/config'
+import type { ConfigSectionKey } from '@oneworks/config'
+import type { Config, ConfigSource } from '@oneworks/types'
+
+export type ConfigReadSource = ConfigSource | 'merged'
+export type ConfigListSource = ConfigReadSource | 'all'
+
+export const CONFIG_READ_SOURCES = ['global', 'project', 'user', 'merged'] as const
+export const CONFIG_SET_SOURCES = ['global', 'project', 'user'] as const
+export const CONFIG_LIST_SOURCES = ['all', ...CONFIG_READ_SOURCES] as const
+export const CONFIG_VALUE_TYPES = ['auto', 'string', 'json', 'number', 'boolean', 'null'] as const
+
+export type ConfigValueType = typeof CONFIG_VALUE_TYPES[number]
+
+export interface ConfigListOptions {
+  json?: boolean
+  source?: ConfigListSource
+}
+
+export interface ConfigGetOptions {
+  json?: boolean
+  source?: ConfigReadSource
+}
+
+export interface ConfigSetOptions {
+  json?: boolean
+  source?: ConfigSource
+  type?: ConfigValueType
+}
+
+export interface ConfigUnsetOptions {
+  json?: boolean
+  source?: ConfigSource
+}
+
+export interface LoadedConfigCommandState {
+  workspaceFolder: string
+  effectiveProjectConfig?: Config
+  globalConfig?: Config
+  globalSourceConfig?: Config
+  projectSourceConfig?: Config
+  projectConfig?: Config
+  userSourceConfig?: Config
+  userConfig?: Config
+  mergedConfig: Config
+  sections: {
+    global: ReturnType<typeof buildConfigSections>
+    project: ReturnType<typeof buildConfigSections>
+    user: ReturnType<typeof buildConfigSections>
+    merged: ReturnType<typeof buildConfigSections>
+  }
+  present: Record<ConfigReadSource, boolean>
+}
+
+export const isInteractiveTerminal = () => process.stdin.isTTY && process.stdout.isTTY
+
+export const formatDisplayValue = (value: unknown) => formatConfigValueAsYaml(value)
+
+export const formatErrorMessage = (error: unknown) => error instanceof Error ? error.message : String(error)
+
+export const printJsonResult = (value: unknown) => {
+  console.log(JSON.stringify(value, null, 2))
+}
+
+export const loadCommandState = async (cwd: string): Promise<LoadedConfigCommandState> => {
+  const configState = await loadConfigState({
+    cwd,
+    jsonVariables: buildConfigJsonVariables(cwd, process.env)
+  })
+  const globalSourceConfig = configState.globalSource?.rawConfig
+  const projectSourceConfig = configState.projectSource?.rawConfig
+  const userSourceConfig = configState.userSource?.rawConfig
+
+  return {
+    workspaceFolder: cwd,
+    globalSourceConfig,
+    projectSourceConfig,
+    userSourceConfig,
+    ...configState,
+    sections: {
+      global: buildConfigSections(globalSourceConfig),
+      project: buildConfigSections(projectSourceConfig),
+      user: buildConfigSections(userSourceConfig),
+      merged: buildConfigSections(configState.mergedConfig)
+    },
+    present: {
+      global: configState.globalSource?.configPath != null,
+      project: configState.projectSource?.configPath != null,
+      user: configState.userSource?.configPath != null,
+      merged: true
+    }
+  }
+}
+
+export const resolveSourceConfig = (
+  state: LoadedConfigCommandState,
+  source: ConfigReadSource
+) => {
+  switch (source) {
+    case 'global':
+      return state.globalSourceConfig
+    case 'project':
+      return state.projectSourceConfig
+    case 'user':
+      return state.userSourceConfig
+    case 'merged':
+      return state.mergedConfig
+  }
+}
+
+export const resolveSourceSections = (
+  state: LoadedConfigCommandState,
+  source: ConfigReadSource
+) => state.sections[source]
+
+export const assertWritableConfigSection = (source: ConfigSource, section: ConfigSectionKey) => {
+  const writeError = resolveConfigSectionWriteError(source, section)
+  if (writeError != null) {
+    throw new Error(writeError)
+  }
+}
+
+export const parseConfigValueInput = (
+  rawValue: string | undefined,
+  type: ConfigValueType
+): unknown => {
+  if (type === 'null') {
+    return null
+  }
+
+  if (rawValue == null) {
+    throw new TypeError('A config value is required.')
+  }
+
+  if (type === 'string') {
+    return rawValue
+  }
+
+  const trimmed = rawValue.trim()
+
+  if (type === 'json') {
+    return JSON.parse(trimmed)
+  }
+
+  if (type === 'number') {
+    const parsed = Number(trimmed)
+    if (!Number.isFinite(parsed)) {
+      throw new TypeError(`Invalid number value "${rawValue}".`)
+    }
+    return parsed
+  }
+
+  if (type === 'boolean') {
+    if (trimmed === 'true') return true
+    if (trimmed === 'false') return false
+    throw new TypeError(`Invalid boolean value "${rawValue}". Expected true or false.`)
+  }
+
+  if (trimmed === '') {
+    return ''
+  }
+
+  const looksLikeJsonLiteral = trimmed.startsWith('{') ||
+    trimmed.startsWith('[') ||
+    trimmed.startsWith('"') ||
+    trimmed === 'true' ||
+    trimmed === 'false' ||
+    trimmed === 'null' ||
+    /^[+-]?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i.test(trimmed)
+
+  return looksLikeJsonLiteral ? JSON.parse(trimmed) : rawValue
+}
+
+export const formatValidationIssues = (
+  error: {
+    issues: Array<{
+      path: Array<string | number>
+      message: string
+    }>
+  }
+) =>
+  error.issues
+    .map((issue) => {
+      const path = issue.path.length > 0 ? issue.path.join('.') : '<root>'
+      return `${path}: ${issue.message}`
+    })
+    .join('\n')

package/src/commands/kill.ts

@@ -0,0 +1,41 @@
+import process from 'node:process'
+
+import type { Command } from 'commander'
+
+import { formatListCommand, formatResumeCommand } from '#~/session-cache.js'
+import { resolveCliWorkspaceCwd } from '#~/workspace.js'
+
+import { signalCliSession } from './session-control'
+
+export function registerKillCommand(program: Command) {
+  program
+    .command('kill <sessionId>')
+    .description('Force kill a running CLI session')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  oneworks list --running
+  oneworks kill <sessionId>
+`
+    )
+    .action(async (sessionId: string) => {
+      try {
+        const result = await signalCliSession({
+          cwd: resolveCliWorkspaceCwd(),
+          sessionId,
+          signal: 'SIGKILL'
+        })
+        console.log(result.message)
+        console.log(
+          `Tips:\n  Check running sessions: ${formatListCommand({ running: true })}\n  Resume later: ${
+            formatResumeCommand(sessionId)
+          }`
+        )
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        console.error(message)
+        process.exit(1)
+      }
+    })
+}

package/src/commands/list.ts

@@ -0,0 +1,224 @@
+import process from 'node:process'
+
+import type { TaskDetail } from '@oneworks/types'
+import { Option } from 'commander'
+import type { Command } from 'commander'
+
+import {
+  formatKillCommand,
+  formatListCommand,
+  formatResumeCommand,
+  formatStopCommand,
+  listCliSessions,
+  resolveCliSessionAdapter,
+  resolveCliSessionCtxId,
+  resolveCliSessionDescription,
+  resolveCliSessionId,
+  resolveCliSessionModel,
+  resolveCliSessionUpdatedAt
+} from '#~/session-cache.js'
+import { resolveCliWorkspaceCwd } from '#~/workspace.js'
+
+interface ListOptions {
+  all?: boolean
+  json?: boolean
+  limit?: string
+  running?: boolean
+  status?: string[]
+  verbose?: boolean
+  view?: ListView
+}
+
+interface ListRow {
+  sessionId: string
+  ctxId: string
+  status: TaskDetail['status'] | 'unknown'
+  adapter: string
+  model: string
+  updatedAt: number
+  pid?: number
+  description: string
+  resumeCommand: string
+  stopCommand: string
+  killCommand: string
+}
+
+const TASK_STATUSES = ['pending', 'running', 'completed', 'failed', 'stopped'] as const
+const LIST_VIEWS = ['compact', 'default', 'full'] as const
+
+type TaskStatus = (typeof TASK_STATUSES)[number]
+type ListView = (typeof LIST_VIEWS)[number]
+
+const isTaskStatus = (value: string): value is TaskStatus => (TASK_STATUSES as readonly string[]).includes(value)
+
+const truncate = (value: string | undefined, maxLength: number) => {
+  if (value == null || value === '') return ''
+  return value.length > maxLength ? `${value.slice(0, maxLength - 3)}...` : value
+}
+
+const formatUpdatedAt = (updatedAt: number) => updatedAt === 0 ? '' : new Date(updatedAt).toLocaleString()
+
+const resolveListView = (view: ListView | undefined, verbose: boolean | undefined): ListView =>
+  verbose ? 'full' : (view ?? 'compact')
+
+const buildListRows = (records: Awaited<ReturnType<typeof listCliSessions>>) => (
+  records.map((record) => {
+    const sessionId = resolveCliSessionId(record)
+    const status = record.detail?.status ?? 'unknown'
+
+    return {
+      sessionId,
+      ctxId: resolveCliSessionCtxId(record),
+      status,
+      adapter: resolveCliSessionAdapter(record),
+      model: resolveCliSessionModel(record),
+      updatedAt: resolveCliSessionUpdatedAt(record),
+      pid: record.detail?.pid,
+      description: resolveCliSessionDescription(record),
+      resumeCommand: sessionId === '' ? '' : formatResumeCommand(sessionId),
+      stopCommand: status === 'running' && sessionId !== '' ? formatStopCommand(sessionId) : '',
+      killCommand: status === 'running' && sessionId !== '' ? formatKillCommand(sessionId) : ''
+    } satisfies ListRow
+  })
+)
+
+const renderListRows = (rows: ListRow[], view: ListView) => {
+  switch (view) {
+    case 'compact':
+      return rows.map((row) => ({
+        Session: row.sessionId,
+        Status: row.status,
+        Updated: formatUpdatedAt(row.updatedAt),
+        Description: truncate(row.description, 72)
+      }))
+    case 'default':
+      return rows.map((row) => ({
+        Session: row.sessionId,
+        Status: row.status,
+        Adapter: row.adapter,
+        Model: row.model,
+        Updated: formatUpdatedAt(row.updatedAt),
+        Description: truncate(row.description, 72)
+      }))
+    case 'full':
+      return rows.map((row) => ({
+        Session: row.sessionId,
+        Context: row.ctxId,
+        Status: row.status,
+        Adapter: row.adapter,
+        Model: row.model,
+        Updated: formatUpdatedAt(row.updatedAt),
+        PID: row.pid ?? '',
+        Description: truncate(row.description, 72),
+        Resume: row.resumeCommand,
+        Stop: row.stopCommand,
+        Kill: row.killCommand
+      }))
+  }
+}
+
+const buildListHints = (rows: ListRow[], view: ListView) => {
+  const hints: string[] = []
+  const latest = rows[0]
+  const running = rows.find(row => row.stopCommand !== '')
+
+  if (latest?.resumeCommand) {
+    hints.push(`Resume latest: ${latest.resumeCommand}`)
+  }
+  if (running?.stopCommand) {
+    hints.push(`Stop a running session: ${running.stopCommand}`)
+  }
+
+  switch (view) {
+    case 'compact':
+      hints.push(`More columns: ${formatListCommand({ view: 'default' })}`)
+      break
+    case 'default':
+      hints.push(`All columns: ${formatListCommand({ view: 'full' })}`)
+      break
+    case 'full':
+      break
+  }
+
+  return hints
+}
+
+const printListHints = (rows: ListRow[], view: ListView) => {
+  const hints = buildListHints(rows, view)
+  if (hints.length === 0) return
+  console.log(`Tips:\n  ${hints.join('\n  ')}`)
+}
+
+export function registerListCommand(program: Command) {
+  program
+    .command('list')
+    .alias('ls')
+    .description('List cached CLI sessions')
+    .option('--all', 'Show all sessions', false)
+    .option('--json', 'Print JSON output', false)
+    .option('--limit <count>', 'Limit displayed sessions')
+    .option('--running', 'Show only running sessions', false)
+    .option('--status <status...>', `Filter by status (${TASK_STATUSES.join(', ')})`)
+    .addOption(
+      new Option('--view <view>', 'Display view')
+        .choices([...LIST_VIEWS])
+        .default('compact')
+    )
+    .option('--verbose', 'Alias for --view full', false)
+    .addHelpText(
+      'after',
+      `
+Examples:
+  oneworks list
+  oneworks list --view default
+  oneworks list --view full
+  oneworks list --running
+`
+    )
+    .action(async (opts: ListOptions) => {
+      try {
+        const records = await listCliSessions(resolveCliWorkspaceCwd())
+        if (records.length === 0) {
+          console.log('No cached sessions found.')
+          return
+        }
+
+        const requestedStatuses = new Set<TaskDetail['status']>()
+        if (opts.running) requestedStatuses.add('running')
+        for (const status of opts.status ?? []) {
+          if (!isTaskStatus(status)) {
+            throw new Error(`Unsupported status "${status}". Expected one of: ${TASK_STATUSES.join(', ')}`)
+          }
+          requestedStatuses.add(status)
+        }
+
+        const limit = opts.all
+          ? records.length
+          : Math.max(1, Number.parseInt(opts.limit ?? '20', 10) || 20)
+        const view = resolveListView(opts.view, opts.verbose)
+        const rows = buildListRows(records)
+          .filter((record) => (
+            requestedStatuses.size === 0 ||
+            (record.status !== 'unknown' && requestedStatuses.has(record.status))
+          ))
+          .slice(0, limit)
+
+        if (rows.length === 0) {
+          console.log('No cached sessions matched the requested filters.')
+          return
+        }
+
+        if (opts.json) {
+          console.log(JSON.stringify(rows, null, 2))
+          return
+        }
+
+        console.table(renderListRows(rows, view))
+        printListHints(rows, view)
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        console.error(message)
+        process.exit(1)
+      }
+    })
+}

package/src/commands/memory/context.ts

@@ -0,0 +1,76 @@
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+
+import { mergeProcessEnvWithProjectEnv, resolveProjectHomePath } from '@oneworks/utils'
+
+import type { MemoryCommandOptions, MemoryContext } from './shared'
+import { trimNonEmpty } from './shared'
+
+const MEMORY_ROOT_ENV = '__ONEWORKS_PROJECT_CHANNEL_MEMORY_ROOT__'
+const CHANNEL_TYPE_ENV = '__ONEWORKS_PROJECT_CHANNEL_TYPE__'
+const CHANNEL_KEY_ENV = '__ONEWORKS_PROJECT_CHANNEL_KEY__'
+const CHANNEL_ID_ENV = '__ONEWORKS_PROJECT_CHANNEL_ID__'
+const CHANNEL_SESSION_TYPE_ENV = '__ONEWORKS_PROJECT_CHANNEL_SESSION_TYPE__'
+const CHANNEL_SENDER_ID_ENV = '__ONEWORKS_PROJECT_CHANNEL_SENDER_ID__'
+const CHANNEL_CONTEXT_PATH_ENV = '__ONEWORKS_PROJECT_CHANNEL_CONTEXT_PATH__'
+const SESSION_ID_ENV = '__ONEWORKS_PROJECT_SESSION_ID__'
+
+const resolveRoot = (cwd: string, env: NodeJS.ProcessEnv) => {
+  const explicitRoot = trimNonEmpty(env[MEMORY_ROOT_ENV])
+  if (explicitRoot != null) return path.resolve(explicitRoot)
+
+  const serverDataDir = trimNonEmpty(env.__ONEWORKS_PROJECT_SERVER_DATA_DIR__)
+  const dataRoot = serverDataDir == null
+    ? resolveProjectHomePath(cwd, env, 'server', 'data')
+    : path.resolve(serverDataDir)
+  return path.resolve(dataRoot, 'channel-memory', 'v1')
+}
+
+const readChannelContext = (env: NodeJS.ProcessEnv) => {
+  const contextPath = trimNonEmpty(env[CHANNEL_CONTEXT_PATH_ENV])
+  if (contextPath == null) return undefined
+
+  try {
+    const parsed = JSON.parse(readFileSync(contextPath, 'utf8')) as unknown
+    if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined
+    return parsed as Record<string, unknown>
+  } catch {
+    return undefined
+  }
+}
+
+export const resolveContext = (options: MemoryCommandOptions): MemoryContext => {
+  const cwd = options.cwd ?? process.cwd()
+  const env = mergeProcessEnvWithProjectEnv(options.env, { workspaceFolder: cwd }) as NodeJS.ProcessEnv
+  const channelContext = readChannelContext(env)
+  const contextChannelType = trimNonEmpty(channelContext?.channelType)
+  const contextChannelKey = trimNonEmpty(channelContext?.channelKey)
+  const contextSessionType = trimNonEmpty(channelContext?.sessionType)
+  const contextChannelId = trimNonEmpty(channelContext?.channelId)
+  const contextSenderId = trimNonEmpty(channelContext?.senderId)
+  const contextSessionId = trimNonEmpty(channelContext?.sessionId)
+  const channelRef = trimNonEmpty(options.channel) ?? contextChannelType ?? trimNonEmpty(env[CHANNEL_TYPE_ENV])
+  const channelParts = channelRef?.split(':') ?? []
+  const channelType = channelParts[0] || contextChannelType || trimNonEmpty(env[CHANNEL_TYPE_ENV])
+  const channelKey = channelParts[1] || contextChannelKey || trimNonEmpty(env[CHANNEL_KEY_ENV])
+  const channelId = contextChannelId ?? trimNonEmpty(env[CHANNEL_ID_ENV])
+  const channelSessionType = contextSessionType ?? trimNonEmpty(env[CHANNEL_SESSION_TYPE_ENV])
+  const senderId = contextSenderId ?? (
+    channelSessionType === 'group'
+      ? undefined
+      : trimNonEmpty(env[CHANNEL_SENDER_ID_ENV])
+  ) ??
+    (channelSessionType === 'direct' ? channelId : undefined)
+
+  return {
+    channelId,
+    channelKey,
+    channelRef,
+    channelSessionType,
+    channelType,
+    root: resolveRoot(cwd, env),
+    senderId,
+    sessionId: contextSessionId ?? trimNonEmpty(env[SESSION_ID_ENV]) ?? trimNonEmpty(env.__ONEWORKS_PROJECT_CTX_ID__)
+  }
+}