@oneworks/cli 0.1.0-alpha.0

package/src/commands/accounts.ts

@@ -0,0 +1,204 @@
+import process from 'node:process'
+
+import { buildConfigJsonVariables, loadConfig } from '@oneworks/config'
+import type { AdapterCtx, AdapterManageAccountProgressEvent } from '@oneworks/types'
+import { loadAdapter } from '@oneworks/types'
+import {
+  mergeProcessEnvWithProjectEnv,
+  persistAdapterAccountArtifacts,
+  removeStoredAdapterAccount
+} from '@oneworks/utils'
+import { createLogger } from '@oneworks/utils/create-logger'
+import type { Command } from 'commander'
+
+import { resolveCliWorkspaceCwd } from '#~/workspace.js'
+import { normalizeCliAdapterOptionValue } from './@core/adapter-option'
+
+const createTransientCache = (): AdapterCtx['cache'] => {
+  const store = new Map<string, unknown>()
+
+  return {
+    set: async (key, value) => {
+      store.set(String(key), value)
+      return { cachePath: '' }
+    },
+    get: async (key) => store.get(String(key)) as any
+  }
+}
+
+const loadCliAdapterContext = async (adapterKey: string, cwd: string) => {
+  const env = mergeProcessEnvWithProjectEnv(undefined, { workspaceFolder: cwd })
+  const [projectConfig, userConfig] = await loadConfig({
+    cwd,
+    env,
+    jsonVariables: buildConfigJsonVariables(cwd, env)
+  })
+  const adapter = await loadAdapter(adapterKey)
+  const adapterCtx = {
+    ctxId: `cli-adapter-accounts-${adapterKey}`,
+    cwd,
+    env,
+    cache: createTransientCache(),
+    logger: createLogger(cwd, `cli/adapter-accounts/${adapterKey}`, 'cli', '', 'info', env),
+    configs: [projectConfig, userConfig]
+  } satisfies AdapterCtx
+
+  return {
+    adapter,
+    adapterCtx
+  }
+}
+
+const printAccountSummary = (prefix: string, summary: {
+  key: string
+  title: string
+  description?: string
+  quota?: { summary?: string }
+  status?: string
+}) => {
+  console.log(`${prefix}: ${summary.title} (${summary.key})`)
+  if (summary.status != null && summary.status !== '') {
+    console.log(`Status: ${summary.status}`)
+  }
+  if (summary.description != null && summary.description !== '') {
+    console.log(`Description: ${summary.description}`)
+  }
+  if (summary.quota?.summary != null && summary.quota.summary !== '') {
+    console.log(`Quota: ${summary.quota.summary}`)
+  }
+}
+
+const printAccountActionProgress = (event: AdapterManageAccountProgressEvent) => {
+  if (event.stream === 'stdout') {
+    process.stdout.write(event.message)
+    return
+  }
+  if (event.stream === 'stderr') {
+    process.stderr.write(event.message)
+    return
+  }
+  console.log(event.message)
+}
+
+export function registerAccountsCommand(program: Command) {
+  const accountsCommand = program
+    .command('accounts')
+    .description('Manage adapter accounts stored in project-home runtime data')
+
+  accountsCommand
+    .command('add <adapter> [account]')
+    .description('Run the adapter login flow and save credentials into project-private account storage')
+    .action(async (adapterInput: string, account: string | undefined) => {
+      try {
+        const adapterKey = normalizeCliAdapterOptionValue(adapterInput)
+        const cwd = resolveCliWorkspaceCwd()
+        const { adapter, adapterCtx } = await loadCliAdapterContext(adapterKey, cwd)
+        if (adapter.manageAccount == null) {
+          throw new Error(`Adapter "${adapterKey}" does not support account management.`)
+        }
+
+        const result = await adapter.manageAccount(adapterCtx, {
+          action: 'add',
+          account,
+          onProgress: printAccountActionProgress
+        })
+
+        if ((result.artifacts?.length ?? 0) > 0) {
+          if (result.accountKey == null || result.accountKey.trim() === '') {
+            throw new Error('Adapter returned account artifacts without an account key.')
+          }
+          await persistAdapterAccountArtifacts({
+            cwd,
+            env: adapterCtx.env,
+            adapter: adapterKey,
+            account: result.accountKey,
+            artifacts: result.artifacts!
+          })
+        }
+
+        const detail = result.accountKey != null && adapter.getAccountDetail != null
+          ? await adapter.getAccountDetail(adapterCtx, {
+            account: result.accountKey,
+            refresh: true
+          }).catch(() => undefined)
+          : undefined
+
+        if (result.message != null && result.message.trim() !== '') {
+          console.log(result.message)
+        }
+        if (detail?.account != null) {
+          printAccountSummary('Connected account', detail.account)
+          return
+        }
+        if (result.account != null) {
+          printAccountSummary('Connected account', result.account)
+          return
+        }
+        if (result.accountKey != null) {
+          console.log(`Connected account key: ${result.accountKey}`)
+        }
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error))
+        process.exit(1)
+      }
+    })
+
+  accountsCommand
+    .command('show <adapter> <account>')
+    .description('Show the latest account detail and quota snapshot for one adapter account')
+    .action(async (adapterInput: string, account: string) => {
+      try {
+        const adapterKey = normalizeCliAdapterOptionValue(adapterInput)
+        const cwd = resolveCliWorkspaceCwd()
+        const { adapter, adapterCtx } = await loadCliAdapterContext(adapterKey, cwd)
+        if (adapter.getAccountDetail == null) {
+          throw new Error(`Adapter "${adapterKey}" does not support account detail.`)
+        }
+
+        const detail = await adapter.getAccountDetail(adapterCtx, {
+          account,
+          refresh: true
+        })
+        printAccountSummary('Account', detail.account)
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error))
+        process.exit(1)
+      }
+    })
+
+  accountsCommand
+    .command('remove <adapter> <account>')
+    .description('Remove the project-private credential snapshot for one adapter account')
+    .action(async (adapterInput: string, account: string) => {
+      try {
+        const adapterKey = normalizeCliAdapterOptionValue(adapterInput)
+        const cwd = resolveCliWorkspaceCwd()
+        const { adapter, adapterCtx } = await loadCliAdapterContext(adapterKey, cwd)
+        if (adapter.manageAccount == null) {
+          throw new Error(`Adapter "${adapterKey}" does not support account management.`)
+        }
+
+        const result = await adapter.manageAccount(adapterCtx, {
+          action: 'remove',
+          account
+        })
+
+        if (result.removeStoredAccount === true) {
+          if (result.accountKey == null || result.accountKey.trim() === '') {
+            throw new Error('Adapter remove action requires an account key.')
+          }
+          await removeStoredAdapterAccount({
+            cwd,
+            env: adapterCtx.env,
+            adapter: adapterKey,
+            account: result.accountKey
+          })
+        }
+
+        console.log(result.message ?? `Removed adapter account "${account}".`)
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error))
+        process.exit(1)
+      }
+    })
+}

package/src/commands/adapter/prepare-selection.ts

@@ -0,0 +1,181 @@
+import { loadAdapterCliPreparer, normalizeAdapterPackageId } from '@oneworks/types'
+import type { AdapterCliPrepareTarget, AdapterCliPreparer, Config } from '@oneworks/types'
+
+const KNOWN_PREPARE_ADAPTERS = [
+  'codex',
+  'claude-code',
+  'gemini',
+  'copilot',
+  'opencode',
+  'kimi'
+]
+
+const SPECIAL_TARGET_ALIASES: Record<string, { adapter: string; target: string }> = {
+  ccr: {
+    adapter: 'claude-code',
+    target: 'routerCli'
+  },
+  'claude-code-router': {
+    adapter: 'claude-code',
+    target: 'routerCli'
+  }
+}
+
+interface AdapterPrepareRequest {
+  adapter: string
+  target: AdapterCliPrepareTarget
+  preparer: AdapterCliPreparer
+}
+
+type ParsedAdapterPrepareTarget =
+  | { all: true }
+  | { adapter: string; target?: string }
+
+const isPlainRecord = (value: unknown): value is Record<string, unknown> => (
+  value != null && typeof value === 'object' && !Array.isArray(value)
+)
+
+const normalizeAdapterId = (value: string) => {
+  const normalized = normalizeAdapterPackageId(value)
+  return normalized.startsWith('adapter-') ? normalized.slice('adapter-'.length) : normalized
+}
+
+const readPath = (value: unknown, path: string[]) => {
+  let current = value
+  for (const segment of path) {
+    if (!isPlainRecord(current)) return undefined
+    current = current[segment]
+  }
+  return current
+}
+
+const isTargetPrepareOnInstallEnabled = (
+  config: Config,
+  adapter: string,
+  target: AdapterCliPrepareTarget
+) => {
+  const adapterConfig = (config.adapters as Record<string, unknown> | undefined)?.[adapter]
+  const cliConfig = readPath(adapterConfig, target.configPath ?? [target.key])
+  return isPlainRecord(cliConfig) && cliConfig.prepareOnInstall === true
+}
+
+const targetMatches = (target: AdapterCliPrepareTarget, value: string) => (
+  target.key === value || target.aliases?.includes(value) === true
+)
+
+export const parseAdapterPrepareTargetInput = (rawValue: string): ParsedAdapterPrepareTarget | undefined => {
+  const value = rawValue.trim()
+  if (value === '') return undefined
+  if (value === 'all') return { all: true as const }
+
+  const specialTarget = SPECIAL_TARGET_ALIASES[value]
+  if (specialTarget != null) return specialTarget
+
+  const [rawAdapter, rawTarget] = value.split('.', 2)
+  return {
+    adapter: normalizeAdapterId(rawAdapter),
+    target: rawTarget
+  }
+}
+
+const pushUniqueRequest = (
+  requests: AdapterPrepareRequest[],
+  request: AdapterPrepareRequest
+) => {
+  const key = `${request.adapter}.${request.target.key}`
+  if (requests.some(item => `${item.adapter}.${item.target.key}` === key)) return
+  requests.push(request)
+}
+
+export const resolveAdapterPrepareRequests = (params: {
+  all?: boolean
+  config: Config
+  preparers: AdapterCliPreparer[]
+  targets: string[]
+}): AdapterPrepareRequest[] => {
+  const requests: AdapterPrepareRequest[] = []
+
+  if (params.all === true) {
+    for (const preparer of params.preparers) {
+      for (const target of preparer.targets) {
+        pushUniqueRequest(requests, {
+          adapter: preparer.adapter,
+          preparer,
+          target
+        })
+      }
+    }
+    return requests
+  }
+
+  if (params.targets.length === 0) {
+    for (const preparer of params.preparers) {
+      for (const target of preparer.targets) {
+        if (!isTargetPrepareOnInstallEnabled(params.config, preparer.adapter, target)) continue
+        pushUniqueRequest(requests, {
+          adapter: preparer.adapter,
+          preparer,
+          target
+        })
+      }
+    }
+    return requests
+  }
+
+  for (const rawTarget of params.targets) {
+    const parsedTarget = parseAdapterPrepareTargetInput(rawTarget)
+    if (parsedTarget == null) continue
+    if ('all' in parsedTarget) {
+      return resolveAdapterPrepareRequests({
+        ...params,
+        all: true,
+        targets: []
+      })
+    }
+
+    const preparer = params.preparers.find(item => item.adapter === parsedTarget.adapter)
+    if (preparer == null) {
+      throw new Error(`Unknown adapter CLI prepare target: ${rawTarget}`)
+    }
+
+    const targets = parsedTarget.target == null
+      ? preparer.targets
+      : preparer.targets.filter(target => targetMatches(target, parsedTarget.target!))
+    if (targets.length === 0) {
+      throw new Error(`Unknown adapter CLI prepare target: ${rawTarget}`)
+    }
+
+    for (const target of targets) {
+      pushUniqueRequest(requests, {
+        adapter: preparer.adapter,
+        preparer,
+        target
+      })
+    }
+  }
+
+  return requests
+}
+
+export const loadAdapterPreparePreparers = async (params: {
+  config: Config
+  requiredTargets: string[]
+}) => {
+  const configuredAdapters = Object.keys(params.config.adapters ?? {})
+  const requestedAdapters = params.requiredTargets
+    .map(parseAdapterPrepareTargetInput)
+    .filter((value): value is { adapter: string; target?: string } => value != null && !('all' in value))
+    .map(value => value.adapter)
+  const adapterIds = Array.from(new Set([...KNOWN_PREPARE_ADAPTERS, ...configuredAdapters, ...requestedAdapters]))
+  const preparers: AdapterCliPreparer[] = []
+
+  for (const adapterId of adapterIds) {
+    try {
+      preparers.push(await loadAdapterCliPreparer(adapterId))
+    } catch (error) {
+      if (requestedAdapters.includes(adapterId)) throw error
+    }
+  }
+
+  return preparers
+}

package/src/commands/adapter/prepare.ts

@@ -0,0 +1,104 @@
+import process from 'node:process'
+
+import { buildConfigJsonVariables, loadConfigState } from '@oneworks/config'
+import type { AdapterCliPrepareContext, AdapterCliPrepareResult } from '@oneworks/types'
+import { mergeProcessEnvWithProjectEnv } from '@oneworks/utils'
+import {
+  PROJECT_PRIMARY_WORKSPACE_FOLDER_ENV,
+  resolveProjectPrimaryWorkspaceFolder
+} from '@oneworks/utils/project-cache-path'
+
+import { resolveCliWorkspaceCwd } from '#~/workspace.js'
+
+import { loadAdapterPreparePreparers, resolveAdapterPrepareRequests } from './prepare-selection'
+
+export interface AdapterPrepareCommandOptions {
+  all?: boolean
+  fromPostinstall?: boolean
+  json?: boolean
+  quiet?: boolean
+}
+
+const toPrepareEnv = (cwd: string) => {
+  const primaryWorkspaceFolder = resolveProjectPrimaryWorkspaceFolder(cwd, process.env) ?? cwd
+  return mergeProcessEnvWithProjectEnv({
+    __ONEWORKS_PROJECT_WORKSPACE_FOLDER__: cwd,
+    [PROJECT_PRIMARY_WORKSPACE_FOLDER_ENV]: primaryWorkspaceFolder
+  }, { workspaceFolder: cwd })
+}
+
+const createPrepareContext = async (quiet: boolean | undefined): Promise<AdapterCliPrepareContext> => {
+  const cwd = resolveCliWorkspaceCwd()
+  const env = toPrepareEnv(cwd)
+  const configState = await loadConfigState({
+    cwd,
+    env,
+    jsonVariables: buildConfigJsonVariables(cwd, env)
+  })
+  return {
+    cwd,
+    env,
+    configs: [configState.effectiveProjectConfig ?? configState.projectConfig, configState.userConfig],
+    configState,
+    logger: {
+      info: (...args: unknown[]) => {
+        if (quiet === true) return
+        console.error(args.map(arg => typeof arg === 'string' ? arg : JSON.stringify(arg)).join(' '))
+      }
+    }
+  }
+}
+
+const printPrepareResults = (
+  results: AdapterCliPrepareResult[],
+  options: AdapterPrepareCommandOptions
+) => {
+  if (options.json === true) {
+    console.log(JSON.stringify({ ok: true, prepared: results }, null, 2))
+    return
+  }
+
+  if (options.quiet === true) return
+  for (const result of results) {
+    console.log(`Prepared ${result.title}: ${result.binaryPath}`)
+  }
+}
+
+export const runAdapterPrepareCommand = async (
+  targets: string[],
+  options: AdapterPrepareCommandOptions
+) => {
+  const ctx = await createPrepareContext(options.quiet)
+  const preparers = await loadAdapterPreparePreparers({
+    config: ctx.configState?.mergedConfig ?? {},
+    requiredTargets: targets
+  })
+  const requests = resolveAdapterPrepareRequests({
+    all: options.all,
+    config: ctx.configState?.mergedConfig ?? {},
+    preparers,
+    targets
+  })
+
+  if (requests.length === 0) {
+    if (options.json === true) {
+      console.log(JSON.stringify({ ok: true, prepared: [] }, null, 2))
+    } else if (options.quiet !== true) {
+      console.log('No adapter CLI prepare targets selected.')
+      console.log('Set adapters.<adapter>.cli.prepareOnInstall: true, pass --all, or pass target names.')
+    }
+    return
+  }
+
+  const results: AdapterCliPrepareResult[] = []
+  for (const request of requests) {
+    results.push(
+      await request.preparer.prepare(ctx, {
+        target: request.target.key
+      })
+    )
+  }
+  printPrepareResults(results, options)
+}
+
+export { resolveAdapterPrepareRequests } from './prepare-selection'

package/src/commands/adapter.ts

@@ -0,0 +1,48 @@
+import process from 'node:process'
+
+import type { Command } from 'commander'
+import { Option } from 'commander'
+
+import type { AdapterPrepareCommandOptions } from './adapter/prepare'
+import { runAdapterPrepareCommand } from './adapter/prepare'
+
+const formatErrorMessage = (error: unknown) => error instanceof Error ? error.message : String(error)
+
+export { resolveAdapterPrepareRequests } from './adapter/prepare'
+
+export function registerAdapterCommand(program: Command) {
+  const adapterCommand = program
+    .command('adapter')
+    .description('Manage adapter runtime resources')
+
+  adapterCommand
+    .command('prepare [targets...]')
+    .description('Preinstall managed adapter CLI resources into the global bootstrap cache')
+    .option('--all', 'Prepare all known adapter CLI resources', false)
+    .option('--json', 'Print JSON output', false)
+    .option('--quiet', 'Suppress non-error output', false)
+    .addOption(new Option('--from-postinstall', 'Mark this run as a package postinstall prewarm').hideHelp())
+    .addHelpText(
+      'after',
+      `
+Examples:
+  oneworks adapter prepare
+  oneworks adapter prepare --all
+  oneworks adapter prepare codex claude-code gemini
+  oneworks adapter prepare claude-code.routerCli
+`
+    )
+    .action(async (targets: string[], opts: AdapterPrepareCommandOptions) => {
+      try {
+        await runAdapterPrepareCommand(targets, opts)
+      } catch (error) {
+        const message = formatErrorMessage(error)
+        if (opts.json === true) {
+          console.error(JSON.stringify({ ok: false, error: message }, null, 2))
+        } else {
+          console.error(message)
+        }
+        process.exit(1)
+      }
+    })
+}

package/src/commands/agent/actions.ts

@@ -0,0 +1,176 @@
+import process from 'node:process'
+
+import { resolveCliWorkspaceCwd } from '#~/workspace.js'
+
+import { executeRuntimeProtocolCommand } from '../run/protocol'
+import { readRuntimeEvents } from './runtime-store'
+
+export interface AgentStartOptions {
+  avatar?: string
+  entity: string
+  hostSession?: string
+  json?: boolean
+  message: string
+  room?: string
+  roomTitle?: string
+  title?: string
+}
+
+export interface AgentSessionOptions {
+  json?: boolean
+  message?: string
+  request?: string
+  session: string
+  value?: string
+}
+
+export interface AgentEventsOptions {
+  follow?: boolean
+  jsonl?: boolean
+  session: string
+}
+
+const printJson = (value: unknown) => {
+  console.log(JSON.stringify(value, null, 2))
+}
+
+const printJsonl = (value: unknown) => {
+  console.log(JSON.stringify(value))
+}
+
+const exitWithError = (error: unknown): never => {
+  const message = error instanceof Error ? error.message : String(error)
+  console.error(message)
+  process.exit(1)
+}
+
+const unwrapProtocolResult = (result: Awaited<ReturnType<typeof executeRuntimeProtocolCommand>>) => {
+  if (!result.ok) throw new Error(result.error ?? 'Runtime protocol command failed.')
+  return result.result
+}
+
+export const runAgentAction = async (action: () => Promise<void>) => {
+  try {
+    await action()
+  } catch (error) {
+    exitWithError(error)
+  }
+}
+
+export const runAgentStart = async (opts: AgentStartOptions) => {
+  const hostSessionId = opts.hostSession?.trim() ||
+    process.env.__ONEWORKS_AGENT_ROOM_HOST_SESSION_ID__?.trim() ||
+    undefined
+  const roomId = opts.room?.trim() || process.env.__ONEWORKS_AGENT_ROOM_ID__?.trim() || undefined
+  const roomTitle = opts.roomTitle?.trim() || process.env.__ONEWORKS_AGENT_ROOM_TITLE__?.trim() || undefined
+  printJson(
+    unwrapProtocolResult(
+      await executeRuntimeProtocolCommand({
+        type: 'session.start',
+        entity: opts.entity,
+        hostSessionId,
+        memberAvatar: opts.avatar,
+        memberKey: opts.entity,
+        memberLabel: opts.entity,
+        message: opts.message,
+        parentSessionId: hostSessionId,
+        roomId,
+        roomTitle,
+        runTitle: opts.title,
+        title: opts.title
+      }, {
+        cwd: resolveCliWorkspaceCwd()
+      })
+    )
+  )
+}
+
+export const runAgentCommand = async (
+  opts: AgentSessionOptions,
+  type: 'send_message' | 'stop' | 'kill' | 'submit_input' | 'resume'
+) => {
+  const protocolType = (() => {
+    switch (type) {
+      case 'send_message':
+        return 'session.message'
+      case 'submit_input':
+        return 'session.submit'
+      case 'resume':
+        return 'session.resume'
+      case 'kill':
+      case 'stop':
+        return 'session.stop'
+    }
+  })()
+  printJson(
+    unwrapProtocolResult(
+      await executeRuntimeProtocolCommand({
+        type: protocolType,
+        sessionId: opts.session,
+        message: opts.message,
+        mode: type === 'kill' ? 'force' : undefined,
+        requestId: opts.request,
+        value: opts.value
+      }, {
+        cwd: resolveCliWorkspaceCwd()
+      })
+    )
+  )
+}
+
+export const runAgentStatus = async (opts: AgentSessionOptions) => {
+  printJson(
+    unwrapProtocolResult(
+      await executeRuntimeProtocolCommand({
+        type: 'session.status',
+        sessionId: opts.session
+      }, {
+        cwd: resolveCliWorkspaceCwd()
+      })
+    )
+  )
+}
+
+const printFollowEvents = async (params: {
+  cwd: string
+  sessionId: string
+}) => {
+  let printed = 0
+
+  for (;;) {
+    const events = await readRuntimeEvents(params.cwd, params.sessionId)
+    for (const event of events.slice(printed)) {
+      printJsonl(event)
+    }
+    printed = events.length
+    await new Promise(resolve => setTimeout(resolve, 500))
+  }
+}
+
+export const runAgentEvents = async (opts: AgentEventsOptions) => {
+  const cwd = resolveCliWorkspaceCwd()
+  if (opts.follow && !opts.jsonl) {
+    throw new Error('agent events --follow requires --jsonl.')
+  }
+  if (opts.follow) {
+    await printFollowEvents({ cwd, sessionId: opts.session })
+    return
+  }
+
+  const result = unwrapProtocolResult(
+    await executeRuntimeProtocolCommand({
+      type: 'session.events',
+      sessionId: opts.session
+    }, {
+      cwd
+    })
+  )
+  const events = Array.isArray((result as { events?: unknown }).events)
+    ? (result as { events: unknown[] }).events
+    : []
+  if (opts.jsonl) {
+    for (const event of events) printJsonl(event)
+    return
+  }
+  printJson(events)
+}