openshain 0.1.0

package/src/tui/app.tsx

@@ -0,0 +1,223 @@
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { useEffect, useMemo, useState } from "react";
+import type { Controller, ControllerState } from "./controller.ts";
+import { type ScreenLine, screenLines } from "./lines.ts";
+
+const COLORS: Record<ScreenLine["kind"], string | undefined> = {
+  user: "cyan",
+  assistant: undefined,
+  progress: "gray",
+  notice: "yellow",
+  question: "magenta",
+  line: undefined,
+  logo: undefined,
+  banner: undefined,
+  blank: undefined,
+};
+
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+/** Rows that are not history: the header, the input box (three rows) and the status line. */
+const CHROME_ROWS = 5;
+
+function statusText(state: ControllerState, scrolled: number): string {
+  if (scrolled > 0)
+    return `↑ ${scrolled} 行上を表示中。End で最新へ、ホイールか PageUp と PageDown で移動`;
+  const { work, usage } = state.status;
+  const parts = [];
+  if (work) parts.push(`${work.id} ${work.status}`);
+  parts.push(
+    `model ${usage.modelCalls} 回、入力 ${usage.inputTokens}、出力 ${usage.outputTokens} トークン`,
+  );
+  parts.push("/help で使い方");
+  return parts.join(" · ");
+}
+
+/**
+ * The whole terminal: a header, the conversation with the newest rows at the bottom, the input
+ * box, and a status line. The conversation scrolls inside the screen with the mouse wheel, PageUp
+ * and PageDown. The up and down arrows recall the lines sent before; the input is edited in place.
+ */
+export function App({ controller }: { controller: Controller }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [state, setState] = useState<ControllerState>(() => ({ ...controller.state() }));
+  const [input, setInput] = useState("");
+  /** Where the next character goes, counted in characters, not bytes. */
+  const [cursor, setCursor] = useState(0);
+  const [history, setHistory] = useState<string[]>([]);
+  /** While the arrows walk the history: where we are, and what the input held before. */
+  const [recall, setRecall] = useState<{ index: number; draft: string } | undefined>();
+  const [scroll, setScroll] = useState(0);
+  const [size, setSize] = useState({ columns: stdout.columns ?? 80, rows: stdout.rows ?? 24 });
+  const [tick, setTick] = useState(0);
+
+  useEffect(() => controller.subscribe(() => setState({ ...controller.state() })), [controller]);
+  useEffect(() => {
+    if (state.closed) exit();
+  }, [state.closed, exit]);
+  useEffect(() => {
+    const onResize = () => setSize({ columns: stdout.columns ?? 80, rows: stdout.rows ?? 24 });
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  useEffect(() => {
+    if (!state.busy) return;
+    const timer = setInterval(() => setTick((t) => t + 1), 100);
+    return () => clearInterval(timer);
+  }, [state.busy]);
+
+  // One row is left to the terminal: drawing exactly its height makes it scroll on every redraw.
+  const height = Math.max(CHROME_ROWS + 1, size.rows - 1);
+  const width = Math.max(20, size.columns);
+  const paneRows = height - CHROME_ROWS;
+  const lines = useMemo(
+    () => screenLines(state.entries, width).map((line, row) => ({ ...line, row })),
+    [state.entries, width],
+  );
+  const maxScroll = Math.max(0, lines.length - paneRows);
+  const scrolled = Math.min(scroll, maxScroll);
+  const end = lines.length - scrolled;
+  const visible = lines.slice(Math.max(0, end - paneRows), end);
+  const page = Math.max(1, paneRows - 1);
+
+  /** Replaces the input and puts the cursor after it. */
+  const replaceInput = (text: string) => {
+    setInput(text);
+    setCursor([...text].length);
+  };
+
+  useInput((ch, key) => {
+    // The terminal reports the mouse (SGR). The wheel scrolls the conversation; the rest is ignored.
+    if (/\[<\d+;\d+;\d+[Mm]/.test(ch)) {
+      let delta = 0;
+      for (const m of ch.matchAll(/\[<(6[45]);\d+;\d+M/g)) delta += m[1] === "64" ? 3 : -3;
+      if (delta !== 0) setScroll((s) => Math.max(0, Math.min(maxScroll, s + delta)));
+      return;
+    }
+    if (key.ctrl && ch === "c") {
+      if (!controller.interrupt()) void controller.close();
+      return;
+    }
+    if (key.pageUp) return setScroll((s) => Math.min(maxScroll, s + page));
+    if (key.pageDown) return setScroll((s) => Math.max(0, s - page));
+    // Up and down walk the lines sent before; below the newest one is what was being typed.
+    if (key.upArrow) {
+      const index = (recall?.index ?? history.length) - 1;
+      if (index < 0) return;
+      setRecall({ index, draft: recall?.draft ?? input });
+      replaceInput(history[index] ?? "");
+      return;
+    }
+    if (key.downArrow) {
+      if (!recall) return;
+      const index = recall.index + 1;
+      if (index >= history.length) {
+        replaceInput(recall.draft);
+        setRecall(undefined);
+        return;
+      }
+      setRecall({ ...recall, index });
+      replaceInput(history[index] ?? "");
+      return;
+    }
+    // Editing: the cursor moves with the arrows, Home and End (also Ctrl-A and Ctrl-E); Backspace
+    // deletes before it, Delete at it, Ctrl-U everything before it, Ctrl-K everything after it.
+    const chars = [...input];
+    const at = Math.min(cursor, chars.length);
+    if (key.leftArrow) return setCursor(Math.max(0, at - 1));
+    if (key.rightArrow) return setCursor(Math.min(chars.length, at + 1));
+    if (key.home || (key.ctrl && ch === "a")) return setCursor(0);
+    if (key.end || (key.ctrl && ch === "e")) return setCursor(chars.length);
+    if (key.backspace) {
+      if (at === 0) return;
+      setInput([...chars.slice(0, at - 1), ...chars.slice(at)].join(""));
+      setCursor(at - 1);
+      return;
+    }
+    if (key.delete) {
+      setInput([...chars.slice(0, at), ...chars.slice(at + 1)].join(""));
+      return;
+    }
+    if (key.ctrl && ch === "u") {
+      setInput(chars.slice(at).join(""));
+      setCursor(0);
+      return;
+    }
+    if (key.ctrl && ch === "k") return setInput(chars.slice(0, at).join(""));
+    // Ink hands a pasted or quickly typed chunk over whole, and a newline inside it does not set
+    // key.return. The line ends at the first newline; what follows becomes the next input.
+    const newline = key.return ? 0 : ch.search(/[\r\n]/);
+    if (newline >= 0) {
+      const line = [...chars.slice(0, at), ch.slice(0, newline), ...chars.slice(at)].join("");
+      if (line.trim() !== "") setHistory((h) => (h.at(-1) === line ? h : [...h, line]));
+      setRecall(undefined);
+      replaceInput(ch.slice(newline + 1).replace(/^\n/, ""));
+      setScroll(0);
+      void controller.submit(line);
+      return;
+    }
+    if (key.tab || key.escape || key.ctrl || key.meta) return;
+    setInput([...chars.slice(0, at), ch, ...chars.slice(at)].join(""));
+    setCursor(at + [...ch].length);
+  });
+
+  const asking = state.question !== undefined;
+  const chars = [...input];
+  const at = Math.min(cursor, chars.length);
+  const before = chars.slice(0, at).join("");
+  const under = chars[at] ?? "";
+  const after = chars.slice(at + 1).join("");
+  const bottom = state.busy
+    ? `${SPINNER[tick % SPINNER.length]} 作業中。Ctrl-C で止める`
+    : statusText(state, scrolled);
+  return (
+    <Box flexDirection="column" width={width} height={height}>
+      <Text dimColor wrap="truncate">
+        {[
+          "openshain",
+          state.status.company,
+          ...(state.status.agentName ? [`社員エージェント ${state.status.agentName}`] : []),
+          state.status.model,
+        ].join(" · ")}
+      </Text>
+      <Box flexDirection="column" height={paneRows}>
+        {visible.map((line) => {
+          const color = COLORS[line.kind];
+          if (line.segments) {
+            return (
+              <Text key={line.row} wrap="truncate">
+                {line.segments.map((s) => (
+                  <Text key={s.at} color={s.color}>
+                    {s.text}
+                  </Text>
+                ))}
+              </Text>
+            );
+          }
+          return (
+            <Text
+              key={line.row}
+              wrap="truncate"
+              dimColor={line.kind === "banner"}
+              {...(color && { color })}
+            >
+              {line.text || " "}
+            </Text>
+          );
+        })}
+      </Box>
+      <Box borderStyle="round" borderColor={asking ? "magenta" : "gray"} paddingX={1}>
+        <Text color={asking ? "magenta" : "cyan"}>{asking ? "答え> " : "> "}</Text>
+        <Text>{before}</Text>
+        {under === "" ? <Text dimColor>▌</Text> : <Text inverse>{under}</Text>}
+        <Text>{after}</Text>
+      </Box>
+      <Text dimColor wrap="truncate">
+        {bottom}
+      </Text>
+    </Box>
+  );
+}

package/src/tui/banner.ts

@@ -0,0 +1,40 @@
+import cli from "../../package.json" with { type: "json" };
+
+/** The version of the openshain command, from its package.json. */
+export const VERSION: string = cli.version;
+
+/**
+ * The wordmark as `oh-my-logo "openshain" --filled --block-font chrome` draws it, kept here so the
+ * screen needs neither the network nor another dependency to show it.
+ */
+export const LOGO_ROWS: readonly string[] = Object.freeze([
+  " ╔═╗ ╔═╗ ╔═╗ ╔╗╔ ╔═╗ ╦ ╦ ╔═╗ ╦ ╔╗╔",
+  " ║ ║ ╠═╝ ║╣  ║║║ ╚═╗ ╠═╣ ╠═╣ ║ ║║║",
+  " ╚═╝ ╩   ╚═╝ ╝╚╝ ╚═╝ ╩ ╩ ╩ ╩ ╩ ╝╚╝",
+]);
+
+/** oh-my-logo's grad-blue palette, from the left edge of the wordmark to the right. */
+const GRADIENT: readonly [readonly [number, number, number], readonly [number, number, number]] = [
+  [78, 168, 255],
+  [127, 136, 255],
+];
+
+export interface Segment {
+  text: string;
+  color: string;
+  /** Position in the row; the screen keys by it. */
+  at: number;
+}
+
+/** One colored segment per character, so the gradient runs across the row. */
+export function logoSegments(row: string): Segment[] {
+  const chars = [...row];
+  const last = Math.max(1, chars.length - 1);
+  return chars.map((text, at) => {
+    const t = at / last;
+    const [from, to] = GRADIENT;
+    const channel = (k: 0 | 1 | 2) => Math.round(from[k] + (to[k] - from[k]) * t);
+    const hex = [channel(0), channel(1), channel(2)].map((v) => v.toString(16).padStart(2, "0"));
+    return { text, color: `#${hex.join("")}`, at };
+  });
+}

package/src/tui/controller.ts

@@ -0,0 +1,357 @@
+import { createSession, type Session, type TurnResult } from "@openshain/agent";
+import {
+  type AnyEvent,
+  createRuntime,
+  type Event,
+  type Runtime,
+  type RuntimeProviders,
+  type WorkId,
+} from "@openshain/core";
+import { progressLine, report } from "../commands/run.ts";
+import { toolsList } from "../commands/tools.ts";
+import { workList, workResume, workShow } from "../commands/work.ts";
+import { plain } from "../format.ts";
+import { statusLabel } from "../labels.ts";
+import { LOGO_ROWS, VERSION } from "./banner.ts";
+
+/** logo and banner are the rows shown once when the screen opens: the wordmark, the version, the folder. */
+export type EntryKind =
+  | "user"
+  | "assistant"
+  | "progress"
+  | "notice"
+  | "question"
+  | "line"
+  | "logo"
+  | "banner";
+
+export interface Entry {
+  id: number;
+  kind: EntryKind;
+  text: string;
+}
+
+export interface ControllerState {
+  /**
+   * Everything shown so far, in order. An entry never changes once added, and the array is
+   * replaced rather than mutated: the screen tells new entries apart by the array's identity.
+   */
+  entries: Entry[];
+  busy: boolean;
+  /** A question a work is asking; the next line the person types answers it. */
+  question?: string;
+  closed: boolean;
+  status: {
+    company: string;
+    model: string;
+    /** The name the agent goes by in this conversation. */
+    agentName?: string;
+    work?: { id: string; status: string };
+    usage: { modelCalls: number; inputTokens: number; outputTokens: number };
+  };
+}
+
+export interface Controller {
+  readonly sessionId: WorkId;
+  state(): ControllerState;
+  subscribe(listener: () => void): () => void;
+  /** A line the person typed: an answer, a slash command, or something to say. */
+  submit(line: string): Promise<void>;
+  /** Ctrl-C: stops the running work, taking back a question it waits on; false when nothing was running. */
+  interrupt(): boolean;
+  /** Stops whatever is running, then ends the session. A second call waits for the same close. */
+  close(): Promise<void>;
+}
+
+export interface ControllerOptions {
+  workspaceRoot: string;
+  providers: RuntimeProviders;
+  runtime?: Runtime;
+}
+
+const HELP = [
+  "/work list         Work の一覧",
+  "/work show <id>    Work の詳細",
+  "/work resume <id>  止まった Work を続ける",
+  "/tools             使える Tool",
+  "/quit              終わる",
+  "↑ ↓                前に送った行を入力欄に呼び戻す。いちばん下は新しい入力",
+  "← → Home End       入力欄でカーソルを動かす。Backspace と Delete はカーソルの位置で消す",
+  "ホイール、PageUp/PageDown  会話を遡る。送ると最新に戻る",
+  "Ctrl-C             動いている Work を止める。質問待ちなら質問を取り下げる。何も動いていなければ終わる",
+];
+
+/** What the session's model hears when the person stops a work that waits for their answer. */
+const QUESTION_WITHDRAWN =
+  "the person stopped the work while it waited for their answer; the question is still pending and the work can be resumed";
+
+/** The state behind the screen: a session, the works it starts, and the lines to show. */
+export async function createController(options: ControllerOptions): Promise<Controller> {
+  const runtime =
+    options.runtime ??
+    (await createRuntime({ workspaceRoot: options.workspaceRoot, providers: options.providers }));
+  const listeners = new Set<() => void>();
+  let nextId = 1;
+  const state: ControllerState = {
+    entries: [],
+    busy: false,
+    closed: false,
+    status: {
+      company: runtime.config.company.name,
+      model: `${runtime.config.model.provider}/${runtime.config.model.model}`,
+      usage: { modelCalls: 0, inputTokens: 0, outputTokens: 0 },
+    },
+  };
+  // A listener may act on the controller and cause another notification; those run after this one.
+  let notifying = false;
+  let again = false;
+  const notify = () => {
+    if (notifying) {
+      again = true;
+      return;
+    }
+    notifying = true;
+    try {
+      do {
+        again = false;
+        for (const listener of listeners) listener();
+      } while (again);
+    } finally {
+      notifying = false;
+    }
+  };
+  const push = (kind: EntryKind, text: string) => {
+    state.entries = [...state.entries, { id: nextId++, kind, text: plain(text) }];
+    notify();
+  };
+
+  let pending: { resolve: (text: string) => void; reject: (reason: Error) => void } | undefined;
+  let aborter: AbortController | undefined;
+  let running: Promise<void> | undefined;
+  let closing: Promise<void> | undefined;
+  /** The child work of the current turn while it is unfinished. */
+  let lastWorkId: WorkId | undefined;
+  const names = new Map<string, string>();
+
+  const ask = (workId: WorkId, question: string): Promise<string> => {
+    state.question = question;
+    push("question", `${question}(${workId})`);
+    return new Promise((resolve, reject) => {
+      pending = { resolve, reject };
+    });
+  };
+  /** Answers the pending question, or takes it back when there is no answer. */
+  const settleQuestion = (answer?: string) => {
+    const waiting = pending;
+    pending = undefined;
+    if (state.question !== undefined) {
+      delete state.question;
+      notify();
+    }
+    if (!waiting) return;
+    if (answer === undefined) waiting.reject(new Error(QUESTION_WITHDRAWN));
+    else waiting.resolve(answer);
+  };
+
+  /** The lines the CLI prints when a work ends, shown among the progress lines. */
+  const closingLines = async (workId: WorkId) => {
+    for (const line of await workReport(runtime, workId)) push("progress", line.trimStart());
+  };
+
+  const onWorkEvent = (workId: WorkId, event: AnyEvent): void | Promise<void> => {
+    lastWorkId = workId;
+    if (event.type === "work.status_changed") {
+      state.status.work = {
+        id: workId,
+        status: (event as Event<"work.status_changed">).payload.to,
+      };
+    } else if (event.type === "work.completed" || event.type === "work.failed") {
+      lastWorkId = undefined;
+      state.status.work = {
+        id: workId,
+        status: event.type === "work.completed" ? "completed" : "failed",
+      };
+      return closingLines(workId);
+    }
+    const line = progressLine(event, names);
+    if (line) push("progress", line);
+    else notify();
+  };
+
+  const session: Session = await createSession(runtime, {
+    onEvent: (event) => {
+      if (event.type === "usage.recorded") {
+        const { payload } = event as Event<"usage.recorded">;
+        if (payload.kind === "model_inference") {
+          state.status.usage.modelCalls += 1;
+          state.status.usage.inputTokens += payload.usage.inputTokens;
+          state.status.usage.outputTokens += payload.usage.outputTokens;
+          notify();
+        }
+      }
+    },
+    onWorkEvent,
+    onInput: ask,
+  });
+  state.status.agentName = session.agentName;
+  for (const row of LOGO_ROWS) push("logo", row);
+  push("banner", `openshain ${VERSION}`);
+  push("banner", runtime.workspaceRoot);
+
+  const stopped = (workId: string | undefined) =>
+    workId
+      ? `止めました。${workId} は途中のまま残っています。/work resume ${workId} で続けられます。`
+      : "止めました。";
+
+  const explain = (result: TurnResult) => {
+    switch (result.stopped) {
+      case "turn_limit":
+        return "社員エージェントが 1 回の返答でできる回数を超えたので、ここで止めました。続きを頼めます。";
+      case "aborted":
+        return stopped(lastWorkId);
+      case "max_tokens":
+        return "返答が長さの上限で切れました。";
+      case "refusal":
+        return "社員エージェントが続けられないと言っています。";
+      case "model_error":
+        return `model の呼び出しに失敗しました。${result.detail ?? ""}`.trim();
+      default:
+        return undefined;
+    }
+  };
+
+  const message = (err: unknown) => (err instanceof Error ? err.message : String(err));
+
+  /** Runs one thing the person can stop with Ctrl-C, and keeps the screen busy meanwhile. */
+  const stoppable = async (fn: (signal: AbortSignal) => Promise<void>) => {
+    const stopper = new AbortController();
+    aborter = stopper;
+    state.busy = true;
+    notify();
+    running = fn(stopper.signal);
+    try {
+      await running;
+    } finally {
+      running = undefined;
+      aborter = undefined;
+      state.busy = false;
+      notify();
+    }
+  };
+
+  const capture = async (fn: (write: (line: string) => void) => Promise<unknown>) => {
+    try {
+      await fn((line) => push("line", line));
+    } catch (err) {
+      push("notice", message(err));
+    }
+  };
+
+  const command = async (line: string) => {
+    const [name, ...args] = line.slice(1).trim().split(/\s+/);
+    const sub = args[0] ?? "";
+    const id = args[1] ?? args[0] ?? "";
+    if (name === "help") for (const h of HELP) push("line", h);
+    else if (name === "quit" || name === "exit") await close();
+    else if (name === "tools") await capture((write) => toolsList({ ...options, write }));
+    else if (name === "work" && sub === "list")
+      await capture((write) => workList({ workspaceRoot: options.workspaceRoot, write }));
+    else if (name === "work" && (sub === "show" || sub === "resume") && !args[1])
+      push("notice", `/work ${sub} には Work の id が要ります。/work list で確かめてください。`);
+    else if (name === "work" && sub === "show" && id)
+      await capture((write) => workShow({ workspaceRoot: options.workspaceRoot, id, write }));
+    else if (name === "work" && sub === "resume" && id) {
+      await stoppable(async (signal) => {
+        try {
+          await workResume({
+            workspaceRoot: options.workspaceRoot,
+            providers: options.providers,
+            id,
+            signal,
+            write: (text) => push("line", text),
+            ask: (q) => ask(id as WorkId, q),
+          });
+        } catch (err) {
+          if (!signal.aborted) push("notice", message(err));
+        }
+        if (signal.aborted) push("notice", stopped(id));
+      });
+    } else if (name === "resume") {
+      push(
+        "notice",
+        "セッションの再開はまだありません。止まった Work を続けるなら /work resume <id> です。",
+      );
+    } else {
+      push("notice", `分からないコマンドです。/help で一覧が出ます。`);
+    }
+  };
+
+  function close(): Promise<void> {
+    closing ??= (async () => {
+      aborter?.abort();
+      settleQuestion();
+      await running;
+      await session.close();
+      state.closed = true;
+      notify();
+    })();
+    return closing;
+  }
+
+  return {
+    sessionId: session.id,
+    state: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async submit(line) {
+      const text = line.trim();
+      if (text === "" || closing) return;
+      if (pending) {
+        push("user", text);
+        // Everything typed answers the question, except leaving: that takes the question back.
+        if (text === "/quit" || text === "/exit") await close();
+        else settleQuestion(text);
+        return;
+      }
+      if (state.busy) {
+        push("notice", "いま動いています。止めるなら Ctrl-C。");
+        return;
+      }
+      if (text.startsWith("/")) {
+        push("user", text);
+        await command(text);
+        return;
+      }
+      push("user", text);
+      await stoppable(async (signal) => {
+        try {
+          const result = await session.turn(text, { signal });
+          if (result.reply) push("assistant", result.reply);
+          const note = explain(result);
+          if (note) push("notice", note);
+        } catch (err) {
+          push("notice", message(err));
+        }
+      });
+    },
+    interrupt() {
+      if (!aborter) return false;
+      aborter.abort();
+      settleQuestion();
+      return true;
+    },
+    close,
+  };
+}
+
+/** Lines that close a work in the screen: the CLI's closing lines without the summary, which the clerk relays. */
+export async function workReport(runtime: Runtime, workId: WorkId): Promise<string[]> {
+  const work = await runtime.works.get(workId);
+  const events = await runtime.works.events(workId);
+  const lines = report(work, events);
+  return work.status === "completed" ? ["完了。", ...lines.slice(1)] : lines;
+}
+
+export { statusLabel };

package/src/tui/index.ts

@@ -0,0 +1,51 @@
+import type { RuntimeProviders } from "@openshain/core";
+import { render } from "ink";
+import React from "react";
+import { App } from "./app.tsx";
+import { createController } from "./controller.ts";
+
+export interface TuiOptions {
+  workspaceRoot: string;
+  providers: RuntimeProviders;
+}
+
+/** The alternate screen, cleared, with the terminal reporting the mouse (SGR) so the wheel reaches the screen. */
+const ENTER_SCREEN = "\x1b[?1049h\x1b[H\x1b[2J\x1b[?1000h\x1b[?1006h";
+const LEAVE_SCREEN = "\x1b[?1006l\x1b[?1000l\x1b[?1049l";
+
+/** Opens the conversation screen and returns when the person leaves it. */
+export async function startTui(options: TuiOptions): Promise<number> {
+  const controller = await createController(options);
+  // Whatever ends the process, the terminal gets its screen and its mouse back: an error thrown
+  // while drawing, a signal, or a crash. Written once.
+  let left = false;
+  const leave = () => {
+    if (left) return;
+    left = true;
+    process.stdout.write(LEAVE_SCREEN);
+  };
+  process.once("exit", leave);
+  process.stdout.write(ENTER_SCREEN);
+  try {
+    const { waitUntilExit } = render(React.createElement(App, { controller }), {
+      exitOnCtrlC: false,
+    });
+    // A closed terminal or a stop signal stops what runs and still ends the session in the record.
+    // Registered after render: Ink's own signal handling re-raises a signal when it thinks nobody
+    // else listens.
+    const closeAndExit = () => {
+      controller.close().finally(() => {
+        leave();
+        process.exit(0);
+      });
+    };
+    for (const signal of ["SIGHUP", "SIGTERM", "SIGINT"] as const)
+      process.once(signal, closeAndExit);
+    await waitUntilExit();
+    await controller.close();
+  } finally {
+    leave();
+  }
+  console.log(`会話を終えました。記録は openshain work show ${controller.sessionId} で読めます。`);
+  return 0;
+}