@mitsein-ai/cli 0.2.2 → 0.3.0

package/src/core/chat-output.ts

@@ -0,0 +1,93 @@
+import type { ChatEvent } from './chat-stream.js';
+import { isTTY } from './output.js';
+
+function formatLocalTime(tsSec: number): string {
+  const d = new Date(tsSec * 1000);
+  const h = String(d.getHours()).padStart(2, '0');
+  const m = String(d.getMinutes()).padStart(2, '0');
+  const s = String(d.getSeconds()).padStart(2, '0');
+  return `${h}:${m}:${s}`;
+}
+
+function truncate(s: string, max: number): string {
+  return s.length > max ? `${s.slice(0, max)}...` : s;
+}
+
+function stringify(v: unknown, limit: number): string {
+  const s = typeof v === 'string' ? v : JSON.stringify(v);
+  return truncate(s ?? '', limit);
+}
+
+/** Human-friendly single-line render of one chat SSE event. */
+export function printChatEventHuman(event: ChatEvent): void {
+  const ts = formatLocalTime(event.timestamp);
+  const d = event.data;
+  const dim = '\x1b[2m';
+  const reset = '\x1b[0m';
+  const bold = '\x1b[1m';
+
+  switch (event.type) {
+    case 'text': {
+      const content = typeof d.content === 'string' ? d.content : '';
+      process.stdout.write(`${dim}[${ts}]${reset} ${bold}assistant:${reset} ${content}\n`);
+      return;
+    }
+    case 'tool_call': {
+      const name = typeof d.name === 'string' ? d.name : '?';
+      const args = stringify(d.args ?? d.arguments ?? '', 80);
+      process.stdout.write(`${dim}[${ts}]${reset} \x1b[33mtool_call:${reset}  ${name}(${args})\n`);
+      return;
+    }
+    case 'tool_result': {
+      const name = typeof d.name === 'string' ? d.name : '?';
+      const output = stringify(d.content ?? d.output ?? '', 100);
+      const status = typeof d.status === 'string' ? ` [${d.status}]` : '';
+      process.stdout.write(`${dim}[${ts}]${reset} \x1b[32mtool_result:${reset} ${name}${status} ${output}\n`);
+      return;
+    }
+    case 'done': {
+      const reason = typeof d.reason === 'string' ? d.reason : 'completed';
+      process.stdout.write(`${dim}[${ts}]${reset} \x1b[34mdone:${reset} ${reason}\n`);
+      return;
+    }
+    case 'error': {
+      const msg = typeof d.message === 'string' ? d.message : stringify(d, 120);
+      process.stdout.write(`${dim}[${ts}]${reset} ${bold}\x1b[31merror:${reset} ${msg}\n`);
+      return;
+    }
+    default: {
+      const snippet = stringify(d, 120);
+      process.stdout.write(`${dim}[${ts}] ${event.type}: ${snippet}${reset}\n`);
+    }
+  }
+}
+
+/** Completion summary printed after a streaming run (TTY only, non-JSON). */
+export function printRunSummary(result: Record<string, unknown>): void {
+  const status = String(result.status ?? '');
+  const durationMs = Number(result.duration_ms ?? 0) / 1000;
+  const events = result.events_count;
+
+  if (status === 'completed') {
+    process.stdout.write(
+      `\n\x1b[1m\x1b[32m✓\x1b[0m run completed in ${durationMs.toFixed(1)}s (${events} events)\n`,
+    );
+  } else if (status === 'error') {
+    const err = String(result.error ?? '');
+    process.stdout.write(
+      `\n\x1b[1m\x1b[31m✗\x1b[0m run failed in ${durationMs.toFixed(1)}s: ${err}\n`,
+    );
+  } else if (status === 'cancelled') {
+    process.stdout.write(
+      `\n\x1b[33m!\x1b[0m run cancelled after ${durationMs.toFixed(1)}s (${events} events)\n`,
+    );
+  } else if (status === 'disconnected') {
+    process.stdout.write(
+      `\n\x1b[2mdisconnected after ${durationMs.toFixed(1)}s (${events} events)\x1b[0m\n`,
+    );
+  }
+}
+
+export function shouldPrintSummary(streamOutput: boolean, jsonMode: boolean): boolean {
+  return streamOutput && !jsonMode && isTTY();
+}

package/src/core/chat-run.ts

@@ -0,0 +1,156 @@
+import { chatStream, type ChatEvent, type ContentBlockInput } from './chat-stream.js';
+import { printChatEventHuman, printRunSummary, shouldPrintSummary } from './chat-output.js';
+import { CliError, ExitCode } from './errors.js';
+
+export interface RunChatOptions {
+  endpoint: string;
+  token: string;
+  threadId: string;
+  content?: ContentBlockInput[];
+  lastEventId?: string | null;
+  model?: string | null;
+  timeoutSec?: number | null;
+  debug?: boolean;
+  streamOutput: boolean;
+  jsonMode: boolean;
+  eventFilter?: Set<string> | null;
+  /** Register SIGINT handler that aborts the stream. */
+  cancelOnInterrupt?: boolean;
+  /** Test hook: inject events instead of hitting HTTP. */
+  _eventSource?: AsyncIterable<ChatEvent> | null;
+}
+
+export interface RunChatResult {
+  status: string;
+  thread_id: string;
+  duration_ms: number;
+  events_count: number;
+  last_event_id: string | null;
+  assistant_message?: string;
+  tool_calls?: Record<string, unknown>[];
+  error?: string;
+}
+
+function emitJsonLine(ev: ChatEvent): void {
+  const line = { ts: ev.timestamp, event_id: ev.id, ...ev.data };
+  process.stdout.write(`${JSON.stringify(line)}\n`);
+}
+
+function emitEvent(
+  ev: ChatEvent,
+  streamOutput: boolean,
+  jsonMode: boolean,
+  filter: Set<string> | null | undefined,
+): void {
+  if (!streamOutput) return;
+  if (filter && !filter.has(ev.type)) return;
+  if (jsonMode) {
+    emitJsonLine(ev);
+  } else {
+    printChatEventHuman(ev);
+  }
+}
+
+/**
+ * Drive a `POST /api/next/chat` SSE stream, accumulating state into a
+ * structured result. Mode matrix:
+ * - `streamOutput=true, content=[...]` → live streaming of a fresh run
+ * - `streamOutput=false, content=[...]` → quiet wait for completion
+ * - `content=undefined` → reconnect to an in-progress run (tail/wait)
+ */
+export async function runChat(opts: RunChatOptions): Promise<RunChatResult> {
+  const started = Date.now();
+  let eventsCount = 0;
+  let lastEventId: string | null = null;
+  const assistantParts: string[] = [];
+  const toolCalls: Record<string, unknown>[] = [];
+  let finalStatus = 'unknown';
+  let errorMessage: string | null = null;
+
+  const useBuiltin = opts._eventSource == null;
+  const ac = useBuiltin ? new AbortController() : null;
+  const onSigint = (): void => {
+    ac?.abort();
+  };
+  if (useBuiltin && opts.cancelOnInterrupt) {
+    process.once('SIGINT', onSigint);
+  }
+
+  const stream: AsyncIterable<ChatEvent> =
+    opts._eventSource ??
+    chatStream({
+      endpoint: opts.endpoint,
+      token: opts.token,
+      threadId: opts.threadId,
+      content: opts.content,
+      lastEventId: opts.lastEventId ?? null,
+      model: opts.model ?? null,
+      timeoutSec: opts.timeoutSec ?? null,
+      debug: opts.debug,
+      signal: ac?.signal,
+    });
+
+  try {
+    for await (const ev of stream) {
+      eventsCount += 1;
+      if (ev.id) lastEventId = ev.id;
+      emitEvent(ev, opts.streamOutput, opts.jsonMode, opts.eventFilter);
+
+      const d = ev.data;
+      if (ev.type === 'text') {
+        const c = typeof d.content === 'string' ? d.content : '';
+        if (c) assistantParts.push(c);
+      } else if (ev.type === 'tool_call' || ev.type === 'tool_result') {
+        toolCalls.push(d);
+      } else if (ev.type === 'done') {
+        finalStatus = typeof d.reason === 'string' ? (d.reason as string) : 'completed';
+        break;
+      } else if (ev.type === 'error') {
+        finalStatus = 'error';
+        errorMessage = typeof d.message === 'string' ? (d.message as string) : JSON.stringify(d);
+      }
+    }
+    if (finalStatus === 'unknown') finalStatus = 'disconnected';
+  } catch (e) {
+    if (e !== null && typeof e === 'object' && (e as Error).name === 'AbortError') {
+      finalStatus = 'cancelled';
+      if (!opts.jsonMode) {
+        process.stderr.write('\n\x1b[2mDisconnected (run continues in background)\x1b[0m\n');
+      }
+    } else {
+      throw e;
+    }
+  } finally {
+    if (useBuiltin && opts.cancelOnInterrupt) {
+      process.off('SIGINT', onSigint);
+    }
+  }
+
+  const result: RunChatResult = {
+    status: finalStatus,
+    thread_id: opts.threadId,
+    duration_ms: Date.now() - started,
+    events_count: eventsCount,
+    last_event_id: lastEventId,
+  };
+  if (assistantParts.length > 0) result.assistant_message = assistantParts.join('');
+  if (toolCalls.length > 0) result.tool_calls = toolCalls;
+  if (errorMessage) result.error = errorMessage;
+
+  if (shouldPrintSummary(opts.streamOutput, opts.jsonMode)) {
+    printRunSummary(result as unknown as Record<string, unknown>);
+  }
+
+  if (finalStatus === 'error') {
+    throw new CliError(
+      `Run failed: ${errorMessage ?? 'unknown error'}`,
+      ExitCode.BUSINESS_ERROR,
+      result,
+    );
+  }
+  if (finalStatus === 'timeout') {
+    throw new CliError('Run timeout', ExitCode.TIMEOUT, result);
+  }
+
+  return result;
+}

package/src/core/chat-stream.ts

@@ -0,0 +1,188 @@
+import { CliError, ExitCode, HttpError } from './errors.js';
+
+/** One event from the `/api/next/chat` SSE stream. */
+export interface ChatEvent {
+  /** SSE `id:` line (stable, monotonic `<ts>-<seq>`). `null` if absent. */
+  id: string | null;
+  /** Event discriminator from `data.type` (text/tool_call/tool_result/done/error/...). */
+  type: string;
+  /** Parsed JSON payload. */
+  data: Record<string, unknown>;
+  /** Unix seconds, client-side wall clock at parse time. */
+  timestamp: number;
+}
+
+export interface TextContentInput {
+  type: 'text';
+  text: string;
+}
+
+export interface ImageContentInput {
+  type: 'image_url';
+  image_url: { url: string };
+}
+
+export type ContentBlockInput = TextContentInput | ImageContentInput;
+
+export interface ChatStreamOptions {
+  endpoint: string;
+  token: string;
+  threadId: string;
+  /** Send mode: new prompt. Reconnect mode: omit. */
+  content?: ContentBlockInput[];
+  /** Reconnect resume point. Overridden to `null` in send mode. */
+  lastEventId?: string | null;
+  model?: string | null;
+  /** Wall-clock timeout in seconds. `0` / `null` / `undefined` = no limit. */
+  timeoutSec?: number | null;
+  debug?: boolean;
+  signal?: AbortSignal;
+  /** Test hook: inject a pre-read body instead of calling fetch. */
+  _bodyOverride?: ReadableStream<Uint8Array> | null;
+}
+
+function normalizeBase(endpoint: string): string {
+  return endpoint.replace(/\/$/, '');
+}
+
+function logDebug(debug: boolean | undefined, msg: string): void {
+  if (debug) {
+    process.stderr.write(`[debug] ${msg}\n`);
+  }
+}
+
+/**
+ * Parse a single SSE frame (text between two `\n\n` separators).
+ * Returns `null` for heartbeats (`:comment`) and empty frames.
+ */
+export function parseChatFrame(block: string): ChatEvent | null {
+  const lines = block.split('\n');
+  let eventId: string | null = null;
+  const dataLines: string[] = [];
+  for (const line of lines) {
+    if (line === '' || line.startsWith(':')) continue;
+    if (line.startsWith('id:')) {
+      eventId = line.slice(3).trimStart();
+    } else if (line.startsWith('data:')) {
+      dataLines.push(line.slice(5).trimStart());
+    }
+  }
+  if (dataLines.length === 0) return null;
+
+  const rawData = dataLines.join('\n');
+  let parsed: Record<string, unknown>;
+  try {
+    const obj = JSON.parse(rawData) as unknown;
+    if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
+      parsed = { raw: rawData };
+    } else {
+      parsed = obj as Record<string, unknown>;
+    }
+  } catch {
+    parsed = { raw: rawData };
+  }
+
+  const type = typeof parsed.type === 'string' ? (parsed.type as string) : 'unknown';
+  return {
+    id: eventId,
+    type,
+    data: parsed,
+    timestamp: Date.now() / 1000,
+  };
+}
+
+async function openChatStream(opts: ChatStreamOptions): Promise<ReadableStream<Uint8Array>> {
+  if (opts._bodyOverride) return opts._bodyOverride;
+
+  const url = `${normalizeBase(opts.endpoint)}/api/next/chat`;
+  const body: Record<string, unknown> = {
+    thread_id: opts.threadId,
+  };
+  if (opts.content !== undefined) body.content = opts.content;
+  if (opts.model != null) body.model = opts.model;
+  if (opts.lastEventId != null) body.last_event_id = opts.lastEventId;
+
+  logDebug(opts.debug, `POST ${url}`);
+  logDebug(opts.debug, `body: ${JSON.stringify(body)}`);
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${opts.token}`,
+      'Content-Type': 'application/json',
+      Accept: 'text/event-stream',
+    },
+    body: JSON.stringify(body),
+    signal: opts.signal,
+  });
+
+  logDebug(opts.debug, `→ ${res.status} ${res.headers.get('content-type') ?? ''}`);
+
+  if (!res.ok) {
+    let detail: unknown;
+    let message = `HTTP ${res.status}`;
+    try {
+      const j = (await res.json()) as Record<string, unknown>;
+      detail = j.detail ?? j.error;
+      if (typeof j.message === 'string') message = j.message;
+    } catch {
+      /* ignore */
+    }
+    throw new HttpError(res.status, message, detail);
+  }
+
+  if (!res.body) {
+    throw new CliError('Chat response has no body', ExitCode.HTTP_ERROR);
+  }
+  return res.body;
+}
+
+/**
+ * Stream agent events from `POST /api/next/chat`.
+ *
+ * **Send mode**: pass `content`; starts a new agent run from the user prompt.
+ * **Reconnect mode**: omit `content`, optionally pass `lastEventId`; resumes
+ * an in-progress run's event stream.
+ *
+ * Yields every event until the server closes the stream (normally right after
+ * a `done` event). Raises `CliError(TIMEOUT)` if `timeoutSec` elapses before
+ * the stream ends. Aborts cleanly on `signal` (Ctrl-C); the caller gets the
+ * native `AbortError` and should map it to exit code 130.
+ */
+export async function* chatStream(
+  opts: ChatStreamOptions
+): AsyncGenerator<ChatEvent, void, void> {
+  const started = Date.now();
+  const timeoutMs =
+    opts.timeoutSec == null || opts.timeoutSec === 0 ? null : opts.timeoutSec * 1000;
+
+  const body = await openChatStream(opts);
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      buffer += decoder.decode(value, { stream: true });
+      let sep: number;
+      while ((sep = buffer.indexOf('\n\n')) !== -1) {
+        const block = buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+        const ev = parseChatFrame(block);
+        if (ev === null) continue;
+        yield ev;
+        if (timeoutMs !== null && Date.now() - started > timeoutMs) {
+          throw new CliError('Chat stream timeout', ExitCode.TIMEOUT);
+        }
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+      /* ignore */
+    }
+  }
+}

package/src/core/client.ts

@@ -71,8 +71,15 @@ export class ApiClient {
           'Content-Type': 'application/json',
         },
         retry: 0,
-        onRequest({ request }) {
-          logDebug(dbg, `${request.method} ${request.url}`);
+        onRequest({ request, options }) {
+          const method = (options.method ?? 'GET').toString().toUpperCase();
+          const url =
+            typeof request === 'string'
+              ? request
+              : request instanceof URL
+                ? request.toString()
+                : ((request as Request)?.url ?? '');
+          logDebug(dbg, `${method} ${url}`);
         },
         onResponse({ response }) {
           logDebug(

package/src/core/output.ts

@@ -52,8 +52,21 @@ function replacer(_key: string, value: unknown): unknown {
   return value;
 }
 
+function formatScalar(value: unknown): string {
+  if (value === null) return 'null';
+  if (value === undefined) return '';
+  if (typeof value === 'object') {
+    try {
+      return JSON.stringify(value, replacer);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+
 function printDictHuman(d: Record<string, unknown>): void {
   for (const [key, value] of Object.entries(d)) {
-    process.stdout.write(`${key}: ${String(value)}\n`);
+    process.stdout.write(`${key}: ${formatScalar(value)}\n`);
   }
 }

package/src/index.ts

@@ -7,7 +7,6 @@ import { registerApi } from './commands/api-auto.js';
 import { registerAuth } from './commands/auth.js';
 import { registerDev } from './commands/dev.js';
 import { registerFiles } from './commands/files.js';
-import { registerMessages } from './commands/messages.js';
 import { registerProject } from './commands/project.js';
 import { registerThread } from './commands/thread.js';
 import { runVersion } from './commands/version.js';
@@ -28,7 +27,7 @@ program
   .description('Mitsein CLI — internal dev tool for agent verification and workflow automation.')
   .option('--endpoint <url>', 'API endpoint URL')
   .option('--token <token>', 'Bearer token')
-  .option('--profile <name>', 'Profile name', 'e2e')
+  .option('--profile <name>', 'Profile name', 'default')
   .option('--real', 'Use real account for dev token', false)
   .option('--json', 'Output structured JSON', false)
   .option('--debug', 'Print HTTP request/response details', false)
@@ -49,7 +48,6 @@ program
 registerDev(program);
 registerApi(program);
 registerThread(program);
-registerMessages(program);
 registerAgent(program);
 registerProject(program);
 registerFiles(program);

package/src/commands/messages.ts

@@ -1,61 +0,0 @@
-import type { Command } from 'commander';
-import { ApiClient } from '../core/client.js';
-import { emit, setJsonMode } from '../core/output.js';
-import { handleErrors } from '../core/errors.js';
-import { httpTimeoutSec, readGlobals } from './command-opts.js';
-
-export function registerMessages(program: Command): void {
-  const messages = program.command('messages').description('Message list and send (no agent)');
-
-  messages
-    .command('list <thread_id>')
-    .description('List messages for a thread')
-    .option('--offset <n>', 'Pagination offset', '0')
-    .option('--limit <n>', 'Max results', '20')
-    .action(
-      handleErrors(async function messagesListAction(this: Command, threadId: string) {
-        const g = readGlobals(this);
-        const opts = this.opts() as { offset?: string; limit?: string };
-        setJsonMode(Boolean(g.json));
-        const client = ApiClient.fromOptions({
-          token: g.token,
-          endpoint: g.endpoint,
-          profile: g.profile ?? 'e2e',
-          real: g.real,
-          timeoutSec: httpTimeoutSec(g),
-          debug: g.debug,
-        });
-        const offset = Number.parseInt(String(opts.offset ?? '0'), 10);
-        const limit = Number.parseInt(String(opts.limit ?? '20'), 10);
-        const result = await client.post('/api/message/list', {
-          thread_id: threadId,
-          limit: Number.isFinite(limit) ? limit : 20,
-          offset: Number.isFinite(offset) ? offset : 0,
-        });
-        emit(result);
-      })
-    );
-
-  messages
-    .command('send <thread_id> <content>')
-    .description('Add a user message (does not start the agent)')
-    .action(
-      handleErrors(async function messagesSendAction(this: Command, threadId: string, content: string) {
-        const g = readGlobals(this);
-        setJsonMode(Boolean(g.json));
-        const client = ApiClient.fromOptions({
-          token: g.token,
-          endpoint: g.endpoint,
-          profile: g.profile ?? 'e2e',
-          real: g.real,
-          timeoutSec: httpTimeoutSec(g),
-          debug: g.debug,
-        });
-        const result = await client.post('/api/message/add', {
-          thread_id: threadId,
-          content,
-        });
-        emit(result);
-      })
-    );
-}

package/src/core/sse.ts

@@ -1,135 +0,0 @@
-import { CliError, ExitCode } from './errors.js';
-
-export interface SseEvent {
-  event_type: string;
-  data: Record<string, unknown> | string;
-  raw: string;
-  timestamp: number;
-}
-
-function normalizeBase(endpoint: string): string {
-  return endpoint.replace(/\/$/, '');
-}
-
-/** Parse one SSE block (`\n\n` delimited). Returns `null` for heartbeats / empty. */
-export function parseSseEvent(text: string, debug = false): SseEvent | null {
-  const lines = text.trim().split('\n');
-  const dataLines: string[] = [];
-
-  for (const line of lines) {
-    if (line.startsWith(':')) {
-      if (debug) {
-        process.stderr.write(`[debug] SSE comment: ${line}\n`);
-      }
-      continue;
-    }
-    if (line.startsWith('data: ')) {
-      dataLines.push(line.slice(6));
-    } else if (line.startsWith('data:')) {
-      dataLines.push(line.slice(5));
-    }
-  }
-
-  if (dataLines.length === 0) {
-    return null;
-  }
-
-  const rawData = dataLines.join('\n');
-  const timestamp = Date.now() / 1000;
-
-  try {
-    const parsed = JSON.parse(rawData) as unknown;
-    const event_type =
-      typeof parsed === 'object' &&
-      parsed !== null &&
-      'type' in parsed &&
-      typeof (parsed as { type: unknown }).type === 'string'
-        ? (parsed as { type: string }).type
-        : 'message';
-    return {
-      event_type,
-      data: parsed as Record<string, unknown>,
-      raw: rawData,
-      timestamp,
-    };
-  } catch {
-    return {
-      event_type: 'unknown',
-      data: rawData,
-      raw: rawData,
-      timestamp,
-    };
-  }
-}
-
-export interface StreamSseOptions {
-  endpoint: string;
-  path: string;
-  token: string;
-  timeoutSec?: number | null;
-  debug?: boolean;
-  signal?: AbortSignal | undefined;
-}
-
-/** SSE client using `fetch` + `ReadableStream`. */
-export async function* streamSse(options: StreamSseOptions): AsyncGenerator<SseEvent> {
-  const url = `${normalizeBase(options.endpoint)}${options.path.startsWith('/') ? options.path : `/${options.path}`}`;
-  if (options.debug) {
-    process.stderr.write(`[debug] SSE connecting to ${url}\n`);
-  }
-
-  const start = Date.now();
-  const timeoutMs =
-    options.timeoutSec === undefined || options.timeoutSec === null || options.timeoutSec === 0
-      ? null
-      : options.timeoutSec * 1000;
-
-  const res = await fetch(url, {
-    headers: {
-      Authorization: `Bearer ${options.token}`,
-      Accept: 'text/event-stream',
-    },
-    signal: options.signal,
-  });
-
-  if (!res.ok) {
-    throw new CliError(`SSE connection failed: HTTP ${res.status}`, ExitCode.HTTP_ERROR);
-  }
-
-  if (options.debug) {
-    process.stderr.write(`[debug] SSE connected (${res.status})\n`);
-  }
-
-  const body = res.body;
-  if (!body) {
-    throw new CliError('SSE response has no body', ExitCode.HTTP_ERROR);
-  }
-
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = '';
-
-  try {
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      buffer += decoder.decode(value, { stream: true });
-      let sep: number;
-      while ((sep = buffer.indexOf('\n\n')) !== -1) {
-        const block = buffer.slice(0, sep);
-        buffer = buffer.slice(sep + 2);
-        const ev = parseSseEvent(block, options.debug ?? false);
-        if (ev !== null) {
-          yield ev;
-          if (timeoutMs !== null && Date.now() - start > timeoutMs) {
-            throw new CliError('Stream timeout', ExitCode.TIMEOUT);
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}