@oneworks/cli 0.1.0-alpha.0

package/src/commands/run.ts

@@ -0,0 +1,62 @@
+import { getCliDefaultSkillNames, getCliDefaultSkillPluginConfig } from '#~/default-skill-plugin.js'
+import { createAdapterOption, normalizeCliAdapterOptionValue, parseCliAdapterOptionValue } from './@core/adapter-option'
+import { applyAdapterCliVersionEnv, persistAdapterCliVersionSelection } from './run/adapter-cli-version'
+import { registerRunCommand } from './run/command'
+import { parseCliInputControlEvent } from './run/input-control'
+import {
+  getDisallowedResumeFlags,
+  resolveDefaultOneworksMcpServerOption,
+  resolveInjectDefaultSystemPromptOption,
+  resolveResumeAdapterOptions,
+  resolveRunMode
+} from './run/options'
+import {
+  getAdapterErrorMessage,
+  getAdapterInteractionMessage,
+  getPrintableAssistantText,
+  handlePrintEvent,
+  resolvePrintableStopText,
+  shouldPrintResumeHint
+} from './run/output'
+import { createPrintIdleTimeoutController, parsePrintIdleTimeoutSeconds } from './run/print-idle-timeout'
+import {
+  executeRuntimeProtocolCommand,
+  shouldStartRuntimeConsumer,
+  shouldStartRuntimeResumeConsumer
+} from './run/protocol'
+import { runRuntimeProtocolStdio } from './run/protocol-stdio'
+import { createSessionExitController } from './run/session-exit-controller'
+import { RUN_INPUT_FORMATS, RUN_OUTPUT_FORMATS } from './run/types'
+
+export {
+  RUN_INPUT_FORMATS,
+  RUN_OUTPUT_FORMATS,
+  applyAdapterCliVersionEnv,
+  createAdapterOption,
+  createPrintIdleTimeoutController,
+  createSessionExitController,
+  executeRuntimeProtocolCommand,
+  getAdapterErrorMessage,
+  getAdapterInteractionMessage,
+  getCliDefaultSkillNames,
+  getCliDefaultSkillPluginConfig,
+  getDisallowedResumeFlags,
+  getPrintableAssistantText,
+  handlePrintEvent,
+  normalizeCliAdapterOptionValue,
+  parseCliAdapterOptionValue,
+  parseCliInputControlEvent,
+  parsePrintIdleTimeoutSeconds,
+  persistAdapterCliVersionSelection,
+  registerRunCommand,
+  resolveDefaultOneworksMcpServerOption,
+  resolveInjectDefaultSystemPromptOption,
+  resolvePrintableStopText,
+  resolveResumeAdapterOptions,
+  resolveRunMode,
+  runRuntimeProtocolStdio,
+  shouldPrintResumeHint,
+  shouldStartRuntimeConsumer,
+  shouldStartRuntimeResumeConsumer
+}
+export type { RunInputFormat, RunOptions, RunOutputFormat } from './run/types'

package/src/commands/session-control.ts

@@ -0,0 +1,133 @@
+import process from 'node:process'
+import { setTimeout as delay } from 'node:timers/promises'
+
+import { resolveCliSession, writeCliSessionControl, writeCliSessionRecord } from '#~/session-cache.js'
+
+const STOP_SIGNAL_TIMEOUT_MS = {
+  SIGTERM: 10_000,
+  SIGKILL: 2_000
+} as const
+
+const isProcessAlive = (
+  pid: number,
+  sendSignal: (pid: number, signal?: NodeJS.Signals | number) => void
+) => {
+  try {
+    sendSignal(pid, 0)
+    return true
+  } catch (error: any) {
+    if (error.code === 'ESRCH') return false
+    throw error
+  }
+}
+
+export const waitForProcessExit = async (params: {
+  pid: number
+  timeoutMs: number
+  sendSignal?: (pid: number, signal?: NodeJS.Signals | number) => void
+}) => {
+  const sendSignal = params.sendSignal ?? process.kill
+  const deadline = Date.now() + params.timeoutMs
+
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(params.pid, sendSignal)) return true
+    await delay(100)
+  }
+
+  return !isProcessAlive(params.pid, sendSignal)
+}
+
+const markCliSessionStopped = async (params: {
+  cwd: string
+  record: Awaited<ReturnType<typeof resolveCliSession>>
+  endTime: number
+}) => {
+  const detail = params.record.detail
+  if (detail == null) return
+
+  await writeCliSessionRecord(params.cwd, detail.ctxId, detail.sessionId, {
+    ...params.record,
+    detail: {
+      ...detail,
+      status: 'stopped',
+      endTime: params.endTime
+    }
+  })
+}
+
+export const signalCliSession = async (params: {
+  cwd: string
+  sessionId: string
+  signal: 'SIGTERM' | 'SIGKILL'
+  sendSignal?: (pid: number, signal?: NodeJS.Signals | number) => void
+  waitForExit?: typeof waitForProcessExit
+  now?: () => number
+}) => {
+  const sendSignal = params.sendSignal ?? process.kill
+  const waitForExit = params.waitForExit ?? waitForProcessExit
+  const now = params.now ?? Date.now
+
+  const record = await resolveCliSession(params.cwd, params.sessionId)
+  const detail = record.detail
+  if (detail == null) {
+    throw new Error(`Session ${params.sessionId} has no task metadata.`)
+  }
+
+  if (detail.status !== 'running') {
+    return {
+      message: `Session ${detail.sessionId} is not running (status: ${detail.status}).`
+    }
+  }
+
+  if (detail.pid == null) {
+    throw new Error(`Session ${detail.sessionId} has no PID recorded.`)
+  }
+
+  try {
+    sendSignal(detail.pid, params.signal)
+  } catch (error: any) {
+    if (error.code === 'ESRCH') {
+      await markCliSessionStopped({
+        cwd: params.cwd,
+        record,
+        endTime: now()
+      })
+
+      return {
+        message: `Process ${detail.pid} not found. Marked session ${detail.sessionId} as stopped.`
+      }
+    }
+    throw new Error(`Failed to signal process ${detail.pid}: ${error.message}`)
+  }
+
+  const requestedAt = now()
+  const timeoutMs = STOP_SIGNAL_TIMEOUT_MS[params.signal]
+  await writeCliSessionControl(params.cwd, detail.ctxId, detail.sessionId, {
+    signal: params.signal,
+    requestedAt,
+    expiresAt: requestedAt + timeoutMs
+  })
+
+  const didExit = await waitForExit({
+    pid: detail.pid,
+    timeoutMs,
+    sendSignal
+  })
+
+  if (didExit) {
+    await markCliSessionStopped({
+      cwd: params.cwd,
+      record,
+      endTime: now()
+    })
+
+    return {
+      message: `Sent ${params.signal} to process ${detail.pid} for session ${detail.sessionId}.`
+    }
+  }
+
+  return {
+    message:
+      `Sent ${params.signal} to process ${detail.pid} for session ${detail.sessionId}. Waiting for the session to exit.`
+  }
+}

package/src/commands/skills/add-command.ts

@@ -0,0 +1,88 @@
+import { Option } from 'commander'
+import type { Command } from 'commander'
+
+import { updateConfigFile } from '@oneworks/config'
+import { normalizeProjectSkillInstall, resolveConfiguredSkillInstalls, resolveSkillsRegistry } from '@oneworks/utils'
+
+import { resolveCliWorkspaceCwd } from '#~/workspace.js'
+
+import { buildDeclaredSkillEntry, installDeclaredSkill } from './install'
+import {
+  buildGeneralSkillsUpdateValue,
+  exitWithError,
+  getRawSourceConfig,
+  getResolvedSourceConfig,
+  isSameDeclaredSkill,
+  loadSkillsConfigState,
+  matchesSkillSelector,
+  printResult
+} from './shared'
+import { CONFIG_WRITE_SOURCES } from './types'
+import type { SkillsAddOptions } from './types'
+
+export const registerAddSkillSubcommand = (skillsCommand: Command) => {
+  skillsCommand
+    .command('add <skill>')
+    .description('Declare a project skill in config and ensure it is installed locally')
+    .addOption(
+      new Option('--config-source <source>', 'Config source to update').choices([...CONFIG_WRITE_SOURCES]).default(
+        'project'
+      )
+    )
+    .option('--source <source>', 'Remote skills CLI source path')
+    .option('--version <version>', 'Remote skill version passed to the skills CLI')
+    .option('--rename <name>', 'Local skill name after install')
+    .option('--registry <registry>', 'Package registry used to install the managed skills CLI')
+    .option('--force', 'Replace the existing installed skill if it already exists', false)
+    .option('--json', 'Print JSON output', false)
+    .action(async (skill: string, opts: SkillsAddOptions) => {
+      try {
+        const workspaceFolder = resolveCliWorkspaceCwd()
+        const declared = buildDeclaredSkillEntry(skill, opts)
+        const normalized = normalizeProjectSkillInstall(declared)
+        if (normalized == null) {
+          throw new Error('Skill reference is required.')
+        }
+
+        const state = await loadSkillsConfigState(workspaceFolder)
+        const source = opts.configSource ?? 'project'
+        const sourceConfig = getRawSourceConfig(state, source)
+        const resolvedSourceConfig = getResolvedSourceConfig(state, source)
+        const configured = resolveConfiguredSkillInstalls(sourceConfig?.skills)
+        const resolvedConfigured = resolveConfiguredSkillInstalls(resolvedSourceConfig?.skills)
+        const defaultRegistry = opts.registry ?? resolveSkillsRegistry(resolvedSourceConfig?.skills) ??
+          resolveSkillsRegistry(state.mergedConfig.skills)
+
+        const duplicate = resolvedConfigured.find(item => matchesSkillSelector(normalized.targetName, item))
+        if (duplicate != null && !isSameDeclaredSkill(duplicate, declared)) {
+          throw new Error(`Configured skill target "${normalized.targetName}" already exists in ${source} config.`)
+        }
+
+        const installResult = await installDeclaredSkill({
+          force: opts.force,
+          registry: defaultRegistry,
+          skill: declared,
+          workspaceFolder
+        })
+
+        const nextSkills = duplicate == null ? [...configured, declared] : configured
+        const updated = await updateConfigFile({
+          workspaceFolder,
+          source,
+          section: 'general',
+          value: buildGeneralSkillsUpdateValue(sourceConfig, nextSkills)
+        })
+
+        printResult({
+          action: 'add',
+          configPath: updated.configPath,
+          declared,
+          installDir: installResult.installDir,
+          name: installResult.name,
+          workspaceFolder
+        }, opts.json)
+      } catch (error) {
+        exitWithError(error, opts.json)
+      }
+    })
+}

package/src/commands/skills/install-command.ts

@@ -0,0 +1,105 @@
+import type { Command } from 'commander'
+
+import { resolveSkillsRegistry } from '@oneworks/utils'
+
+import { resolveCliWorkspaceCwd } from '#~/workspace.js'
+
+import { resolveInstallTargets } from './install'
+import { createSkillsProgress } from './progress'
+import { exitWithError, loadSkillsConfigState, printResult } from './shared'
+import { syncProjectSkills } from './sync'
+import type { SkillsInstallOptions } from './types'
+
+export const registerInstallSkillSubcommands = (skillsCommand: Command) => {
+  skillsCommand
+    .command('install [skills...]')
+    .description('Install explicit project skills or all configured skills when no arguments are provided')
+    .option('--source <source>', 'Remote skills CLI source path for a single explicit skill')
+    .option('--version <version>', 'Remote skill version passed to the skills CLI for a single explicit skill')
+    .option('--rename <name>', 'Local skill name after install for a single explicit skill')
+    .option('--registry <registry>', 'Package registry used to install the managed skills CLI')
+    .option('--force', 'Replace existing installed skills', false)
+    .option('--json', 'Print JSON output', false)
+    .action(async (skills: string[], opts: SkillsInstallOptions) => {
+      const progress = createSkillsProgress({ enabled: !opts.json })
+      try {
+        const workspaceFolder = resolveCliWorkspaceCwd()
+        const state = await loadSkillsConfigState(workspaceFolder)
+        const defaultRegistry = opts.registry ?? resolveSkillsRegistry(state.mergedConfig.skills)
+        const targets = await resolveInstallTargets({
+          args: skills,
+          options: opts,
+          workspaceFolder
+        })
+        const result = await syncProjectSkills({
+          force: opts.force,
+          registry: defaultRegistry,
+          progress,
+          state,
+          targets,
+          workspaceFolder
+        })
+        progress.finish(`Installed ${result.installed.length} skills`)
+
+        printResult({
+          action: 'install',
+          installed: result.installed.map(item => ({
+            dirName: item.dirName,
+            installDir: item.installDir,
+            name: item.name,
+            ref: item.ref,
+            skipped: item.skipped
+          })),
+          workspaceFolder
+        }, opts.json)
+      } catch (error) {
+        progress.fail()
+        exitWithError(error, opts.json)
+      }
+    })
+
+  skillsCommand
+    .command('update [skills...]')
+    .description('Force refresh explicit project skills or all configured skills when no arguments are provided')
+    .option('--source <source>', 'Remote skills CLI source path for a single explicit skill')
+    .option('--version <version>', 'Remote skill version passed to the skills CLI for a single explicit skill')
+    .option('--rename <name>', 'Local skill name after install for a single explicit skill')
+    .option('--registry <registry>', 'Package registry used to install the managed skills CLI')
+    .option('--json', 'Print JSON output', false)
+    .action(async (skills: string[], opts: Omit<SkillsInstallOptions, 'force'>) => {
+      const progress = createSkillsProgress({ enabled: !opts.json })
+      try {
+        const workspaceFolder = resolveCliWorkspaceCwd()
+        const state = await loadSkillsConfigState(workspaceFolder)
+        const defaultRegistry = opts.registry ?? resolveSkillsRegistry(state.mergedConfig.skills)
+        const targets = await resolveInstallTargets({
+          args: skills,
+          options: opts,
+          workspaceFolder
+        })
+        const result = await syncProjectSkills({
+          force: true,
+          registry: defaultRegistry,
+          progress,
+          state,
+          targets,
+          workspaceFolder
+        })
+        progress.finish(`Updated ${result.installed.length} skills`)
+
+        printResult({
+          action: 'update',
+          installed: result.installed.map(item => ({
+            dirName: item.dirName,
+            installDir: item.installDir,
+            name: item.name,
+            ref: item.ref
+          })),
+          workspaceFolder
+        }, opts.json)
+      } catch (error) {
+        progress.fail()
+        exitWithError(error, opts.json)
+      }
+    })
+}

package/src/commands/skills/install.ts

@@ -0,0 +1,216 @@
+/* eslint-disable max-lines -- install target resolution stays colocated with command orchestration for now. */
+import { basename, extname } from 'node:path'
+import process from 'node:process'
+
+import type { ConfigSourceState } from '@oneworks/config'
+import type { ConfiguredSkillInstallConfig } from '@oneworks/types'
+import {
+  installProjectSkill,
+  normalizeProjectSkillInstall,
+  resolveConfiguredSkillInstalls,
+  resolveProjectOoPath,
+  toSkillSlug
+} from '@oneworks/utils'
+
+import { loadSkillsConfigState, pathExists } from './shared'
+import type { SkillsInstallOptions } from './types'
+
+export type DeclaredSkillInstallTarget = string | ConfiguredSkillInstallConfig
+
+export interface ResolvedSkillInstallTarget {
+  declaration: DeclaredSkillInstallTarget
+  installPathSegments?: string[]
+}
+
+export const buildDeclaredSkillEntry = (
+  skillArg: string,
+  options: Pick<SkillsInstallOptions, 'registry' | 'rename' | 'source' | 'version'>
+): DeclaredSkillInstallTarget => {
+  const skill = typeof skillArg === 'string' && skillArg.trim() !== '' ? skillArg.trim() : undefined
+  if (skill == null) {
+    throw new Error('Skill reference is required.')
+  }
+
+  const explicitRegistry = typeof options.registry === 'string' && options.registry.trim() !== ''
+    ? options.registry.trim()
+    : undefined
+  const explicitSource = typeof options.source === 'string' && options.source.trim() !== ''
+    ? options.source.trim()
+    : undefined
+  const explicitVersion = typeof options.version === 'string' && options.version.trim() !== ''
+    ? options.version.trim()
+    : undefined
+  const rename = typeof options.rename === 'string' && options.rename.trim() !== ''
+    ? options.rename.trim()
+    : undefined
+  const parsed = normalizeProjectSkillInstall(skill)
+  if (parsed == null) {
+    throw new Error(`Invalid skill reference "${skillArg}".`)
+  }
+
+  if (explicitSource != null && parsed.source != null) {
+    throw new Error('--source cannot be used when the skill reference already includes a source.')
+  }
+  if (explicitRegistry != null && parsed.registry != null) {
+    throw new Error('--registry cannot be used when the skill reference already includes a registry.')
+  }
+  if (explicitVersion != null && parsed.version != null) {
+    throw new Error('--version cannot be used when the skill reference already includes a version.')
+  }
+
+  if (explicitRegistry == null && explicitSource == null && explicitVersion == null && rename == null) {
+    return skill
+  }
+
+  return {
+    name: parsed.name,
+    ...(explicitRegistry != null
+      ? { registry: explicitRegistry }
+      : (parsed.registry != null ? { registry: parsed.registry } : {})),
+    ...(explicitSource != null
+      ? { source: explicitSource }
+      : (parsed.source != null ? { source: parsed.source } : {})),
+    ...(explicitVersion != null
+      ? { version: explicitVersion }
+      : (parsed.version != null ? { version: parsed.version } : {})),
+    ...(rename != null ? { rename } : {})
+  }
+}
+
+const basenameWithoutExtension = (filePath: string) => basename(filePath, extname(filePath))
+
+const isPathLikeExtend = (value: string) => (
+  value.startsWith('.') ||
+  value.startsWith('/') ||
+  /^[a-z]:[\\/]/i.test(value)
+)
+
+const resolveExtendSegmentBaseName = (source: ConfigSourceState, index: number) => {
+  const requestedExtendPath = source.extendPath?.trim()
+  if (requestedExtendPath != null && requestedExtendPath !== '' && !isPathLikeExtend(requestedExtendPath)) {
+    return requestedExtendPath
+  }
+
+  return source.configPath == null ? `extend-${index + 1}` : basenameWithoutExtension(source.configPath)
+}
+
+const stableExtendSegment = (source: ConfigSourceState, index: number, counts: Map<string, number>) => {
+  const baseName = resolveExtendSegmentBaseName(source, index)
+  const slug = toSkillSlug(baseName) || `extend-${index + 1}`
+  if ((counts.get(slug) ?? 0) <= 1) return slug
+  return `${slug}-${index + 1}`
+}
+
+const resolveExtendSegments = (sources: ConfigSourceState[]) => {
+  const counts = new Map<string, number>()
+  for (let index = 0; index < sources.length; index++) {
+    const baseName = resolveExtendSegmentBaseName(sources[index]!, index)
+    const slug = toSkillSlug(baseName) || `extend-${index + 1}`
+    counts.set(slug, (counts.get(slug) ?? 0) + 1)
+  }
+
+  return sources.map((source, index) => stableExtendSegment(source, index, counts))
+}
+
+const resolveConfigSourceInstallTargets = (
+  source: ConfigSourceState | undefined
+): ResolvedSkillInstallTarget[] => {
+  if (source == null) return []
+
+  const extendSources = source.resolvedExtendSources ?? []
+  const extendSegments = resolveExtendSegments(extendSources)
+  const targets: ResolvedSkillInstallTarget[] = []
+
+  for (let index = 0; index < extendSources.length; index++) {
+    targets.push(
+      ...resolveConfiguredSkillInstalls(extendSources[index]?.rawConfig?.skills).map(declaration => ({
+        declaration,
+        installPathSegments: ['.extends', extendSegments[index]!]
+      }))
+    )
+  }
+
+  targets.push(
+    ...resolveConfiguredSkillInstalls(source.rawConfig?.skills).map(declaration => ({
+      declaration,
+      installPathSegments: []
+    }))
+  )
+
+  return targets
+}
+
+const resolveConfiguredSkillInstallTargets = (
+  state: Awaited<ReturnType<typeof loadSkillsConfigState>>
+): ResolvedSkillInstallTarget[] => {
+  const targets = [
+    ...(state.globalConfig == null ? [] : resolveConfigSourceInstallTargets(state.globalSource)),
+    ...resolveConfigSourceInstallTargets(state.projectSource),
+    ...resolveConfigSourceInstallTargets(state.userSource)
+  ]
+  if (targets.length > 0) return targets
+
+  return resolveConfiguredSkillInstalls(state.mergedConfig.skills).map(declaration => ({
+    declaration,
+    installPathSegments: []
+  }))
+}
+
+export const installDeclaredSkill = async (params: {
+  force?: boolean
+  registry?: string
+  skill: DeclaredSkillInstallTarget
+  workspaceFolder: string
+}) => {
+  const normalized = normalizeProjectSkillInstall(params.skill)
+  if (normalized == null) {
+    throw new Error('Skill reference is required.')
+  }
+
+  const existingSkillPath = resolveProjectOoPath(
+    params.workspaceFolder,
+    process.env,
+    'skills',
+    normalized.targetDirName,
+    'SKILL.md'
+  )
+  const hadExisting = await pathExists(existingSkillPath)
+  const installed = params.force === true || !hadExisting
+    ? await installProjectSkill({
+      force: params.force,
+      registry: params.registry,
+      skill: normalized,
+      workspaceFolder: params.workspaceFolder
+    })
+    : {
+      dirName: normalized.targetDirName,
+      installDir: resolveProjectOoPath(params.workspaceFolder, process.env, 'skills', normalized.targetDirName),
+      name: normalized.targetName,
+      ref: normalized.ref,
+      skillPath: existingSkillPath
+    }
+
+  return {
+    ...installed,
+    skipped: params.force !== true && hadExisting
+  }
+}
+
+export const resolveInstallTargets = async (params: {
+  args: string[]
+  options: Pick<SkillsInstallOptions, 'rename' | 'source'>
+  workspaceFolder: string
+}) => {
+  if (params.args.length > 0) {
+    if (params.args.length > 1 && (params.options.rename != null || params.options.source != null)) {
+      throw new Error('--source and --rename only support a single explicit skill argument.')
+    }
+    return params.args.map((arg) => ({
+      declaration: buildDeclaredSkillEntry(arg, params.options),
+      installPathSegments: []
+    }))
+  }
+
+  const state = await loadSkillsConfigState(params.workspaceFolder)
+  return resolveConfiguredSkillInstallTargets(state)
+}