@oneworks/cli 0.1.0-alpha.0

package/src/commands/run/input-bridge.ts

@@ -0,0 +1,108 @@
+import type { Buffer } from 'node:buffer'
+import { createInterface } from 'node:readline'
+
+import type { ChatMessageContent } from '@oneworks/core'
+
+import { parseCliInputControlEvent } from './input-control'
+import type { CliInputControlEvent, CliInputSession, RunInputFormat } from './types'
+
+const dispatchCliInputControlEvent = async (params: {
+  session: CliInputSession
+  event: CliInputControlEvent
+  submitInput?: (event: Extract<CliInputControlEvent, { type: 'submit_input' }>) => void | Promise<void>
+}) => {
+  const { session, event, submitInput } = params
+  if (event.type === 'interrupt') {
+    session.emit({ type: 'interrupt' })
+    return
+  }
+  if (event.type === 'stop') {
+    session.emit({ type: 'stop' })
+    return
+  }
+  if (event.type === 'submit_input') {
+    if (submitInput == null) {
+      throw new TypeError('The current session does not support submit_input events.')
+    }
+    await submitInput(event)
+    return
+  }
+
+  const content = typeof event.content === 'string'
+    ? [{ type: 'text', text: event.content } satisfies ChatMessageContent]
+    : event.content ?? []
+
+  session.emit({
+    type: 'message',
+    content
+  })
+}
+
+export const attachInputBridge = (params: {
+  format: RunInputFormat
+  session: CliInputSession
+  stdin: NodeJS.ReadStream
+  onError: (message: string) => void
+  onInputClosed: () => void
+  submitInput?: (event: Extract<CliInputControlEvent, { type: 'submit_input' }>) => void | Promise<void>
+}) => {
+  const { format, session, stdin, onError, onInputClosed, submitInput } = params
+  stdin.setEncoding('utf8')
+
+  if (format === 'stream-json') {
+    const rl = createInterface({ input: stdin, crlfDelay: Infinity })
+    const onEnd = () => {
+      onInputClosed()
+    }
+    rl.on('line', (line) => {
+      const trimmed = line.trim()
+      if (trimmed === '') return
+      try {
+        void dispatchCliInputControlEvent({
+          session,
+          event: parseCliInputControlEvent(JSON.parse(trimmed)),
+          submitInput
+        }).catch((error) => {
+          onError(error instanceof Error ? error.message : String(error))
+        })
+      } catch (error) {
+        onError(error instanceof Error ? error.message : String(error))
+      }
+    })
+    stdin.once('end', onEnd)
+    return () => {
+      stdin.off('end', onEnd)
+      rl.close()
+    }
+  }
+
+  const chunks: string[] = []
+  const onData = (chunk: string | Buffer) => {
+    chunks.push(String(chunk))
+  }
+  const onEnd = () => {
+    const raw = chunks.join('')
+    if (raw.trim() !== '') {
+      try {
+        const payload = format === 'json' ? JSON.parse(raw) : raw
+        void dispatchCliInputControlEvent({
+          session,
+          event: parseCliInputControlEvent(payload),
+          submitInput
+        }).catch((error) => {
+          onError(error instanceof Error ? error.message : String(error))
+        })
+      } catch (error) {
+        onError(error instanceof Error ? error.message : String(error))
+      }
+    }
+    onInputClosed()
+  }
+
+  stdin.on('data', onData)
+  stdin.once('end', onEnd)
+  return () => {
+    stdin.off('data', onData)
+    stdin.off('end', onEnd)
+  }
+}

package/src/commands/run/input-control.ts

@@ -0,0 +1,112 @@
+import type { ChatMessageContent } from '@oneworks/core'
+
+import type { CliInputControlEvent, RunInputFormat } from './types'
+
+export const supportsPrintInteractionResponses = (format: RunInputFormat | undefined) => format === 'stream-json'
+
+export const supportsRuntimeInteractionResponses = (
+  format: RunInputFormat | undefined,
+  isRuntimeProtocolConsumer: boolean
+) => isRuntimeProtocolConsumer || supportsPrintInteractionResponses(format)
+
+const isChatTextContent = (value: unknown): value is Extract<ChatMessageContent, { type: 'text' }> => (
+  value != null &&
+  typeof value === 'object' &&
+  (value as { type?: unknown }).type === 'text' &&
+  typeof (value as { text?: unknown }).text === 'string'
+)
+
+const isChatImageContent = (value: unknown): value is Extract<ChatMessageContent, { type: 'image' }> => (
+  value != null &&
+  typeof value === 'object' &&
+  (value as { type?: unknown }).type === 'image' &&
+  typeof (value as { url?: unknown }).url === 'string'
+)
+
+const normalizeChatInputContent = (value: unknown): string | ChatMessageContent[] => {
+  if (typeof value === 'string') {
+    return value
+  }
+
+  if (Array.isArray(value)) {
+    const items = value.filter((item): item is ChatMessageContent =>
+      isChatTextContent(item) || isChatImageContent(item)
+    )
+    if (items.length > 0) {
+      return items
+    }
+  }
+
+  throw new Error('Unsupported message content. Use a string or an array of text/image content items.')
+}
+
+const normalizeSubmitInputData = (value: unknown): string | string[] => {
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (trimmed !== '') {
+      return trimmed
+    }
+  }
+
+  if (Array.isArray(value)) {
+    const items = value
+      .filter((item): item is string => typeof item === 'string' && item.trim() !== '')
+      .map(item => item.trim())
+    if (items.length > 0) {
+      return items
+    }
+  }
+
+  throw new Error('Submit input requires a non-empty string or string array in "data" or "response".')
+}
+
+export const parseCliInputControlEvent = (value: unknown): CliInputControlEvent => {
+  if (typeof value === 'string') {
+    return {
+      type: 'message',
+      content: value
+    }
+  }
+
+  if (Array.isArray(value)) {
+    return {
+      type: 'message',
+      content: normalizeChatInputContent(value)
+    }
+  }
+
+  if (value == null || typeof value !== 'object') {
+    throw new Error('Invalid input payload. Expected a string, array, or object.')
+  }
+
+  const record = value as Record<string, unknown>
+  const type = typeof record.type === 'string' ? record.type : 'message'
+  if (type === 'interrupt') {
+    return { type: 'interrupt' }
+  }
+  if (type === 'stop') {
+    return { type: 'stop' }
+  }
+  if (type === 'submit_input' || type === 'interaction_response' || type === 'respond_interaction') {
+    const data = record.data ?? record.response ?? record.answer ?? record.value
+    return {
+      type: 'submit_input',
+      interactionId: typeof record.interactionId === 'string' && record.interactionId.trim() !== ''
+        ? record.interactionId.trim()
+        : undefined,
+      data: normalizeSubmitInputData(data)
+    }
+  }
+  if (type === 'message' || type === 'user_message') {
+    const content = record.content ?? record.text ?? record.message
+    if (content == null) {
+      throw new Error('Message input requires "content" or "text".')
+    }
+    return {
+      type: 'message',
+      content: normalizeChatInputContent(content)
+    }
+  }
+
+  throw new Error(`Unsupported input event type: ${type}`)
+}

package/src/commands/run/input-decision.ts

@@ -0,0 +1,88 @@
+import type { Buffer } from 'node:buffer'
+import { createInterface } from 'node:readline'
+
+import { parseCliInputControlEvent } from './input-control'
+import type { RunInputFormat } from './types'
+
+type PermissionDecisionInput = NodeJS.ReadableStream & {
+  setEncoding(encoding: BufferEncoding): void
+}
+
+const resolveDecisionFromPayload = (payload: unknown) => {
+  const event = parseCliInputControlEvent(payload)
+  if (event.type === 'submit_input') {
+    return event.data
+  }
+  if (event.type === 'message' && typeof event.content === 'string' && event.content.trim() !== '') {
+    return event.content.trim()
+  }
+  throw new TypeError('Permission recovery expects submit_input or a plain text decision like allow_once.')
+}
+
+const readFirstLine = async (stdin: PermissionDecisionInput) =>
+  await new Promise<string>((resolve, reject) => {
+    const rl = createInterface({ input: stdin, crlfDelay: Infinity })
+    let settled = false
+    const cleanup = () => {
+      stdin.off('error', onError)
+      rl.close()
+    }
+    const onError = (error: Error) => {
+      if (settled) return
+      settled = true
+      cleanup()
+      reject(error)
+    }
+    rl.on('line', (line) => {
+      const trimmed = line.trim()
+      if (trimmed === '') return
+      settled = true
+      cleanup()
+      resolve(trimmed)
+    })
+    rl.once('close', () => {
+      if (settled) return
+      settled = true
+      reject(new TypeError('Permission recovery input closed before any decision was provided.'))
+    })
+    stdin.once('error', onError)
+  })
+
+const readAll = async (stdin: PermissionDecisionInput) =>
+  await new Promise<string>((resolve, reject) => {
+    const chunks: string[] = []
+    const onData = (chunk: string | Buffer) => {
+      chunks.push(String(chunk))
+    }
+    const onEnd = () => {
+      cleanup()
+      resolve(chunks.join(''))
+    }
+    const onError = (error: Error) => {
+      cleanup()
+      reject(error)
+    }
+    const cleanup = () => {
+      stdin.off('data', onData)
+      stdin.off('end', onEnd)
+      stdin.off('error', onError)
+    }
+    stdin.on('data', onData)
+    stdin.once('end', onEnd)
+    stdin.once('error', onError)
+  })
+
+export const readCliPermissionDecision = async (params: {
+  format: RunInputFormat
+  stdin: PermissionDecisionInput
+}) => {
+  params.stdin.setEncoding('utf8')
+  if (params.format === 'stream-json') {
+    return resolveDecisionFromPayload(JSON.parse(await readFirstLine(params.stdin)))
+  }
+  if (params.format === 'json') {
+    return resolveDecisionFromPayload(JSON.parse((await readAll(params.stdin)).trim()))
+  }
+
+  return resolveDecisionFromPayload(await readFirstLine(params.stdin))
+}

package/src/commands/run/options.ts

@@ -0,0 +1,104 @@
+import type { Command, OptionValueSource } from 'commander'
+
+import type { CliSessionResumeRecord } from '#~/session-cache.js'
+
+import type { RunOptions, RunOutputFormat } from './types'
+
+const getRunMode = (print: boolean): 'stream' | 'direct' => print ? 'stream' : 'direct'
+
+export const getOutputFormat = (
+  value: RunOutputFormat | undefined,
+  source: OptionValueSource | undefined,
+  fallback: RunOutputFormat
+) => source === 'default' ? fallback : (value ?? 'text')
+
+export const resolveRunMode = (
+  print: boolean,
+  source: OptionValueSource | undefined,
+  fallback: 'stream' | 'direct'
+) => source === 'default' ? 'direct' : getRunMode(print)
+
+export const resolveInjectDefaultSystemPromptOption = (
+  value: boolean | undefined,
+  source: OptionValueSource | undefined
+) => source === 'default' ? undefined : value
+
+export const resolveDefaultOneworksMcpServerOption = (
+  value: boolean | undefined,
+  source: OptionValueSource | undefined
+) => source === 'default' ? undefined : value
+
+export const resolvePermissionModeOption = (
+  permissionMode: RunOptions['permissionMode'],
+  yolo: RunOptions['yolo']
+): RunOptions['permissionMode'] => {
+  if (yolo !== true) return permissionMode
+  if (permissionMode != null && permissionMode !== 'bypassPermissions') {
+    throw new Error('--yolo cannot be combined with --permission-mode unless the mode is bypassPermissions.')
+  }
+  return 'bypassPermissions'
+}
+
+export const getDisallowedResumeFlags = (
+  opts: RunOptions,
+  command: Command
+) => {
+  const disallowed: string[] = []
+
+  if (opts.adapter) disallowed.push('--adapter')
+  if (opts.account) disallowed.push('--account')
+  if (opts.systemPrompt) disallowed.push('--system-prompt')
+  if (opts.sessionId) disallowed.push('--session-id')
+  if (opts.spec) disallowed.push('--spec')
+  if (opts.entity) disallowed.push('--entity')
+  if (opts.workspace) disallowed.push('--workspace')
+  if ((opts.includeMcpServer?.length ?? 0) > 0) disallowed.push('--include-mcp-server')
+  if ((opts.excludeMcpServer?.length ?? 0) > 0) disallowed.push('--exclude-mcp-server')
+  if ((opts.includeSkill?.length ?? 0) > 0) disallowed.push('--include-skill')
+  if ((opts.excludeSkill?.length ?? 0) > 0) disallowed.push('--exclude-skill')
+  if (command.getOptionValueSource('injectDefaultSystemPrompt') !== 'default') {
+    disallowed.push('--no-inject-default-system-prompt')
+  }
+  if (command.getOptionValueSource('defaultOneworksMcpServer') !== 'default') {
+    disallowed.push('--no-default-oneworks-mcp-server')
+  }
+
+  return disallowed
+}
+
+export const mergeListConfig = (
+  config: { include?: string[]; exclude?: string[] } | undefined,
+  includeOpts: string[] | undefined,
+  excludeOpts: string[] | undefined
+) => {
+  const include = config?.include || includeOpts
+    ? [
+      ...(config?.include ?? []),
+      ...(includeOpts ?? [])
+    ]
+    : undefined
+
+  const exclude = config?.exclude || excludeOpts
+    ? [
+      ...(config?.exclude ?? []),
+      ...(excludeOpts ?? [])
+    ]
+    : undefined
+
+  return include || exclude
+    ? {
+      include,
+      exclude
+    }
+    : undefined
+}
+
+export const resolveResumeAdapterOptions = (
+  cached: CliSessionResumeRecord['adapterOptions'],
+  opts: Pick<RunOptions, 'model' | 'effort' | 'includeTool' | 'excludeTool'>
+): CliSessionResumeRecord['adapterOptions'] => ({
+  ...cached,
+  ...(opts.model != null ? { model: opts.model } : {}),
+  ...(opts.effort != null ? { effort: opts.effort } : {}),
+  tools: mergeListConfig(cached.tools, opts.includeTool, opts.excludeTool)
+})

package/src/commands/run/output.ts

@@ -0,0 +1,179 @@
+import type { ChatMessage } from '@oneworks/core'
+import type { AdapterErrorData, AdapterOutputEvent, AskUserQuestionParams, TaskDetail } from '@oneworks/types'
+import { extractTextFromMessage } from '@oneworks/utils/chat-message'
+
+import type { RunOutputFormat } from './types'
+
+export const getPrintableAssistantText = (message: ChatMessage | undefined) => {
+  if (message?.role !== 'assistant') return undefined
+
+  const text = extractTextFromMessage(message).trim()
+  return text === '' ? undefined : text
+}
+
+export const resolvePrintableStopText = (
+  message: ChatMessage | undefined,
+  lastAssistantText: string | undefined
+) => getPrintableAssistantText(message) ?? lastAssistantText
+
+export const getAdapterErrorMessage = (data: AdapterErrorData) => {
+  if (data.code === 'permission_required') {
+    const details = data.details != null && typeof data.details === 'object'
+      ? data.details as { permissionDenials?: Array<{ message?: string; deniedTools?: string[] }> }
+      : undefined
+    const deniedTools = [
+      ...new Set(
+        (details?.permissionDenials ?? []).flatMap(item => Array.isArray(item.deniedTools) ? item.deniedTools : [])
+      )
+    ]
+    return deniedTools.length > 0
+      ? `${data.message}\nDenied tools: ${deniedTools.join(', ')}`
+      : data.message
+  }
+
+  const details = data.details == null
+    ? undefined
+    : typeof data.details === 'string'
+    ? data.details
+    : JSON.stringify(data.details, null, 2)
+
+  return details ? `${data.message}\n${details}` : data.message
+}
+
+export const getAdapterInteractionMessage = (payload: AskUserQuestionParams) => {
+  const header = payload.kind === 'permission' ? 'Permission required' : 'Input required'
+  const optionLines = (payload.options ?? [])
+    .map((option) => {
+      const value = option.value ?? option.label
+      return option.description != null && option.description.trim() !== ''
+        ? `- ${value}: ${option.description}`
+        : `- ${value}`
+    })
+  return optionLines.length > 0
+    ? `${header}\n${payload.question}\nOptions:\n${optionLines.join('\n')}`
+    : `${header}\n${payload.question}`
+}
+
+export const shouldPrintResumeHint = (input: {
+  shouldPrintOutput: boolean
+  status: TaskDetail['status']
+}) => !(input.shouldPrintOutput && input.status === 'completed')
+
+export const handlePrintEvent = (input: {
+  event: AdapterOutputEvent
+  outputFormat: RunOutputFormat
+  lastAssistantText: string | undefined
+  didExitAfterError: boolean
+  exitOnInteractionRequest?: boolean
+  stopExitsStreamJson?: boolean
+  log: (message: string) => void
+  errorLog: (message: string) => void
+  requestExit: (code: number) => void
+}) => {
+  const nextAssistantText = input.event.type === 'message'
+    ? (getPrintableAssistantText(input.event.data) ?? input.lastAssistantText)
+    : input.lastAssistantText
+
+  if (input.event.type === 'interaction_request') {
+    switch (input.outputFormat) {
+      case 'stream-json':
+      case 'json':
+        input.log(JSON.stringify(input.event, null, 2))
+        if (input.exitOnInteractionRequest === true) {
+          input.requestExit(1)
+        }
+        return {
+          lastAssistantText: nextAssistantText,
+          didExitAfterError: input.didExitAfterError || input.exitOnInteractionRequest === true
+        }
+      case 'text':
+        input.errorLog(getAdapterInteractionMessage(input.event.data.payload))
+        if (input.exitOnInteractionRequest === true) {
+          input.requestExit(1)
+        }
+        return {
+          lastAssistantText: nextAssistantText,
+          didExitAfterError: input.didExitAfterError || input.exitOnInteractionRequest === true
+        }
+    }
+  }
+
+  if (input.event.type === 'error') {
+    const isFatal = input.event.data.fatal !== false
+
+    switch (input.outputFormat) {
+      case 'stream-json':
+        input.log(JSON.stringify(input.event, null, 2))
+        if (isFatal) {
+          input.requestExit(1)
+          return {
+            lastAssistantText: nextAssistantText,
+            didExitAfterError: true
+          }
+        }
+        return {
+          lastAssistantText: nextAssistantText,
+          didExitAfterError: input.didExitAfterError
+        }
+      case 'json':
+        if (isFatal) {
+          input.log(JSON.stringify(input.event, null, 2))
+          input.requestExit(1)
+          return {
+            lastAssistantText: nextAssistantText,
+            didExitAfterError: true
+          }
+        }
+        return {
+          lastAssistantText: nextAssistantText,
+          didExitAfterError: input.didExitAfterError
+        }
+      case 'text':
+        if (isFatal) {
+          input.errorLog(getAdapterErrorMessage(input.event.data))
+          input.requestExit(1)
+          return {
+            lastAssistantText: nextAssistantText,
+            didExitAfterError: true
+          }
+        }
+        return {
+          lastAssistantText: nextAssistantText,
+          didExitAfterError: input.didExitAfterError
+        }
+    }
+  }
+
+  switch (input.outputFormat) {
+    case 'stream-json':
+      input.log(JSON.stringify(input.event, null, 2))
+      if (input.event.type === 'stop' && input.stopExitsStreamJson === true && !input.didExitAfterError) {
+        input.requestExit(0)
+      }
+      return {
+        lastAssistantText: nextAssistantText,
+        didExitAfterError: input.didExitAfterError
+      }
+    case 'json':
+      if (input.event.type === 'stop' && !input.didExitAfterError) {
+        input.log(JSON.stringify(input.event, null, 2))
+        input.requestExit(0)
+      }
+      return {
+        lastAssistantText: nextAssistantText,
+        didExitAfterError: input.didExitAfterError
+      }
+    case 'text':
+      if (input.event.type === 'stop' && !input.didExitAfterError) {
+        const output = resolvePrintableStopText(input.event.data, nextAssistantText)
+        if (output != null) {
+          input.log(output)
+        }
+        input.requestExit(0)
+      }
+      return {
+        lastAssistantText: nextAssistantText,
+        didExitAfterError: input.didExitAfterError
+      }
+  }
+}

package/src/commands/run/permission-decision.ts

@@ -0,0 +1,19 @@
+import type { PermissionInteractionDecision } from '@oneworks/types'
+
+import { PERMISSION_DECISION_CANCEL } from './permission-recovery'
+
+export const shouldApplyPermissionDecision = (
+  decision: PermissionInteractionDecision | typeof PERMISSION_DECISION_CANCEL
+) => decision !== PERMISSION_DECISION_CANCEL && decision !== 'deny_once'
+
+export const shouldClearPermissionRecoveryCache = (
+  decision: PermissionInteractionDecision | typeof PERMISSION_DECISION_CANCEL
+) => decision !== PERMISSION_DECISION_CANCEL
+
+export const isTerminalPermissionDecision = (
+  decision: PermissionInteractionDecision | typeof PERMISSION_DECISION_CANCEL
+) => (
+  decision === 'deny_once' ||
+  decision === 'deny_session' ||
+  decision === 'deny_project'
+)