@doguyilmaz/konvoy 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doguyilmaz/konvoy",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "One session across Claude Code, Codex, Kiro CLI and opencode: bind, hand off, fail over.",
   "license": "MIT",
   "type": "module",

package/src/args.ts

@@ -5,7 +5,7 @@ export interface Args {
 
 // Flags that are switches, so `konvoy rm --yes <slug>` keeps its slug. Their consumers are the
 // `=== true` checks in cli.ts; a value flag (--session, --port) is anything not listed here.
-const SWITCHES = new Set(['all', 'yes', 'global', 'chart', 'help'])
+const SWITCHES = new Set(['all', 'yes', 'global', 'chart', 'help', 'h', 'version', 'v', 'V'])
 
 export function parseArgs(argv: string[]): Args {
   const positional: string[] = []

package/src/cli.ts

@@ -22,7 +22,7 @@ import { cmdRename } from './commands/rename'
 import { cmdUsage } from './commands/usage'
 import { cmdDashboard } from './commands/dashboard'
 import { formatCommandList, resolveCommandName, type CommandName } from './commands/table'
-import { runRepl, startSession, type ReplIo } from './commands/repl'
+import { runRepl, startSession, terminalIo, type ReplIo } from './commands/repl'
 import type { AgentId } from './types'
 import pkg from '../package.json'
 
@@ -35,7 +35,7 @@ export const USAGE = `konvoy ${VERSION}
 ${formatCommandList()}
 
 agents: ${agentIds.join(', ')}
-flags:  --session <slug>
+flags:  --session <slug>, --version (-v), --help (-h)
 `
 
 interface CommandContext {
@@ -115,24 +115,28 @@ const handlers: Record<CommandName, Handler> = {
     }),
 }
 
-const stdio = (): ReplIo => ({
-  lines: console as unknown as AsyncIterable<string>,
-  write: (text) => {
-    process.stdout.write(text)
-  },
-  tty: Boolean(process.stdin.isTTY),
-})
-
-export async function main(argv: string[], io: ReplIo = stdio()): Promise<number> {
+export async function main(argv: string[], io?: ReplIo): Promise<number> {
   const args = parseArgs(argv)
   const [command, ...rest] = args._
   const cwd = process.cwd()
   const slug = typeof args.flags.session === 'string' ? args.flags.session : undefined
 
-  if (command === 'help' || args.flags.help) {
+  if (args.flags.version === true || args.flags.v === true || args.flags.V === true) {
+    console.log(`konvoy ${VERSION}`)
+    return 0
+  }
+  if (command === 'help' || args.flags.help === true || args.flags.h === true) {
     console.log(USAGE)
     return 0
   }
+  if (!command) {
+    const stray = Object.keys(args.flags).filter((f) => f !== 'session')
+    if (stray.length > 0) {
+      console.error(`unknown flag ${stray[0]!.length === 1 ? '-' : '--'}${stray[0]}`)
+      console.log(USAGE)
+      return 2
+    }
+  }
 
   try {
     return command ? await dispatch(command, rest, cwd, slug, args) : await interactive(io, cwd, slug)
@@ -160,7 +164,7 @@ async function dispatch(command: string, rest: string[], cwd: string, slug: stri
   return handlers[name]({ db, cfg, cwd, args, slug }, rest)
 }
 
-async function interactive(io: ReplIo, cwd: string, slug: string | undefined): Promise<number> {
+async function interactive(given: ReplIo | undefined, cwd: string, slug: string | undefined): Promise<number> {
   const db = openDb(dbPath())
   const cfg = await loadConfig({ cwd: (slug ? getSessionBySlug(db, slug)?.cwd : undefined) ?? cwd })
   const session = await startSession(db, cfg, cwd, slug)
@@ -168,16 +172,21 @@ async function interactive(io: ReplIo, cwd: string, slug: string | undefined): P
     console.error(slug ? `no konvoy session named "${slug}"` : 'could not create a session here')
     return 2
   }
-  return runRepl(io, db, cfg, cwd, session, (tokens, current) => {
-    const a = parseArgs(tokens)
-    const [cmd = '', ...r] = a._
-    const name = resolveCommandName(cmd)
-    if (!name) {
-      console.error(`unknown command "/${cmd}" - /help lists them`)
-      return 2
-    }
-    return handlers[name]({ db, cfg, cwd, args: a, slug: current }, r)
-  })
+  const io = given ?? terminalIo()
+  try {
+    return await runRepl(io, db, cfg, cwd, session, (tokens, current) => {
+      const a = parseArgs(tokens)
+      const [cmd = '', ...r] = a._
+      const name = resolveCommandName(cmd)
+      if (!name) {
+        console.error(`unknown command "/${cmd}" - /help lists them`)
+        return 2
+      }
+      return handlers[name]({ db, cfg, cwd, args: a, slug: current }, r)
+    })
+  } finally {
+    io.pause()
+  }
 }
 
 if (import.meta.main) {

package/src/commands/repl.ts

@@ -12,6 +12,51 @@ export interface ReplIo {
   lines: AsyncIterable<string>
   write: (text: string) => void
   tty: boolean
+  /** stop reading stdin while a command runs, so a child that inherits the terminal gets every keystroke */
+  pause: () => void
+  resume: () => void
+}
+
+export function terminalIo(): ReplIo {
+  const queue: string[] = []
+  const decoder = new TextDecoder()
+  let buffered = ''
+  let ended = false
+  let wake: (() => void) | undefined
+  const flush = (): void => {
+    wake?.()
+    wake = undefined
+  }
+  process.stdin.on('data', (chunk: Uint8Array) => {
+    buffered += decoder.decode(chunk, { stream: true })
+    let at: number
+    while ((at = buffered.indexOf('\n')) >= 0) {
+      queue.push(buffered.slice(0, at))
+      buffered = buffered.slice(at + 1)
+    }
+    flush()
+  })
+  process.stdin.on('end', () => {
+    if (buffered) queue.push(buffered)
+    ended = true
+    flush()
+  })
+  async function* lines(): AsyncGenerator<string> {
+    for (;;) {
+      if (queue.length > 0) yield queue.shift()!
+      else if (ended) return
+      else await new Promise<void>((resolve) => (wake = resolve))
+    }
+  }
+  return {
+    lines: lines(),
+    write: (text) => {
+      process.stdout.write(text)
+    },
+    tty: Boolean(process.stdin.isTTY),
+    pause: () => process.stdin.pause(),
+    resume: () => process.stdin.resume(),
+  }
 }
 
 /** runs one command line through the command table, as `konvoy <tokens>` would, for the given session */
@@ -52,6 +97,15 @@ export async function runRepl(
     return fresh !== undefined
   }
 
+  const exec = async (tokens: string[]): Promise<void> => {
+    io.pause()
+    try {
+      await run(tokens, session.slug)
+    } finally {
+      io.resume()
+    }
+  }
+
   prompt()
   for await (const raw of io.lines) {
     const line = raw.trim()
@@ -60,7 +114,7 @@ export async function runRepl(
       continue
     }
     if (!line.startsWith('/')) {
-      await run(['send', agent, line], session.slug)
+      await exec(['send', agent, line])
       // failover never falls back, so the agent that answered is the one to keep talking to
       const moved = lastTurnAgent(db, session.id)
       if (moved && moved !== agent) agent = moved
@@ -94,13 +148,13 @@ export async function runRepl(
     } else if (cmd === 'rename') {
       if (rest.length === 0) console.error('usage: /rename <new-name>')
       else {
-        await run(['rename', session.slug, rest.join(' ')], session.slug)
+        await exec(['rename', session.slug, rest.join(' ')])
         refresh()
       }
     } else if (cmd === 'attach') {
-      await run(['attach', rest[0] ?? agent, ...rest.slice(1)], session.slug)
+      await exec(['attach', rest[0] ?? agent, ...rest.slice(1)])
     } else {
-      await run([cmd, ...rest], session.slug)
+      await exec([cmd, ...rest])
       if (cmd === 'resume' && rest[0]) {
         const target = getSessionBySlug(db, rest[0])
         if (target) {