// Demo mode for testing direct interactive mode without a real SDK.

//

// Enabled with `--demo`. Intercepts prompt submissions and generates synthetic

// SDK events that feed through the real reducer and footer pipeline. This

// lets you test scrollback formatting, permission UI, question UI, and tool

// snapshots without making actual model calls. Pass a demo slash command as

// the initial interactive message to trigger a preview immediately.

//

// Slash commands:

// /permission [kind] → triggers a permission request variant

// /question [kind] → triggers a question request variant

// /fmt <kind> → emits a specific tool/text type (text, reasoning, bash,

// write, edit, patch, task, todo, question, error, mix)

//

// Demo mode also handles permission and question replies locally, completing

// or failing the synthetic tool parts as appropriate.

import path from "path"

import type { Event, ToolPart } from "@opencode-ai/sdk/v2"

import { createSessionData, reduceSessionData, type SessionData } from "./session-data"

import { writeSessionOutput } from "./stream"

import type { FooterApi, PermissionReply, QuestionReject, QuestionReply, RunPrompt, StreamCommit } from "./types"

const KINDS = [

"markdown",

"table",

"text",

"reasoning",

"bash",

"write",

"edit",

"patch",

"task",

"todo",

"question",

"error",

"mix",

]

const PERMISSIONS = ["edit", "bash", "read", "task", "external", "doom"] as const

const QUESTIONS = ["multi", "single", "checklist", "custom"] as const

type PermissionKind = (typeof PERMISSIONS)[number]

type QuestionKind = (typeof QUESTIONS)[number]

function permissionKind(value: string | undefined): PermissionKind | undefined {

const next = (value || "edit").toLowerCase()

return PERMISSIONS.find((item) => item === next)

}

function questionKind(value: string | undefined): QuestionKind | undefined {

const next = (value || "multi").toLowerCase()

return QUESTIONS.find((item) => item === next)

}

const SAMPLE_MARKDOWN = [

"# Direct Mode Demo",

"",

"This is a realistic assistant response for direct-mode formatting checks.",

"It mixes **bold**, _italic_, `inline code`, links, code fences, and tables in one streamed reply.",

"",

"## Summary",

"",

"- Restored the final markdown flush so the last block is committed on idle.",

"- Switched markdown scrollback commits back to top-level block boundaries.",

"- Added footer-level regression coverage for split-footer rendering.",

"",

"## Status",

"",

"| Area | Before | After | Notes |",

"| --- | --- | --- | --- |",

"| Direct mode | Missing final rows | Stable | Final markdown block now flushes on idle |",

"| Tables | Dropped in streaming mode | Visible | Block-based commits match the working OpenTUI demo |",

"| Tests | Partial coverage | Broader coverage | Includes a footer-level split render capture |",

"",

"> This sample intentionally includes a wide table so you can spot wrapping and commit bugs quickly.",

"",

"```ts",

"const result = { markdown: true, tables: 2, stable: true }",

"```",

"",

"## Files",

"",

"| File | Change |",

"| --- | --- |",

"| `scrollback.surface.ts` | Align markdown commit logic with the split-footer demo |",

"| `footer.ts` | Keep active surfaces across footer-height-only resizes |",

"| `footer.test.ts` | Capture real split-footer markdown payloads during idle completion |",

"",

"Next step: run `/fmt table` if you want a tighter table-only sample.",

].join("\n")

const SAMPLE_TABLE = [

"# Table Sample",

"",

"| Kind | Example | Notes |",

"| --- | --- | --- |",

"| Pipe | `A\\|B` | Escaped pipes should stay in one cell |",

"| Unicode | `漢字` | Wide characters should remain aligned |",

"| Wrap | `LongTokenWithoutNaturalBreaks_1234567890` | Useful for width stress |",

"| Status | done | Final row should still appear after idle |",

].join("\n")

type Ref = {

msg: string

part: string

call: string

tool: string

input: Record<string, unknown>

start: number

}

type Ask = {

ref: Ref

}

type Perm = {

ref: Ref

done: {

title: string

output: string

metadata?: Record<string, unknown>

}

}

type Permit = {

ref: Ref

permission: string

patterns: string[]

metadata?: Record<string, unknown>

always: string[]

done: Perm["done"]

}

type State = {

id: string

thinking: boolean

data: SessionData

footer: FooterApi

limits: () => Record<string, number>

msg: number

part: number

call: number

perm: number

ask: number

perms: Map<string, Perm>

asks: Map<string, Ask>

}

type Input = {

sessionID: string

thinking: boolean

limits: () => Record<string, number>

footer: FooterApi

}

function note(footer: FooterApi, text: string): void {

footer.append({

kind: "system",

text,

phase: "start",

source: "system",

})

}

function clearSubagent(footer: FooterApi): void {

footer.event({

type: "stream.subagent",

state: {

tabs: [],

details: {},

permissions: [],

questions: [],

},

})

}

function showSubagent(

state: State,

input: {

sessionID: string

partID: string

callID: string

label: string

description: string

status: "running" | "completed" | "cancelled" | "error"

title?: string

toolCalls?: number

commits: StreamCommit[]

},

) {

state.footer.event({

type: "stream.subagent",

state: {

tabs: [

{

sessionID: input.sessionID,

partID: input.partID,

callID: input.callID,

label: input.label,

description: input.description,

status: input.status,

title: input.title,

toolCalls: input.toolCalls,

lastUpdatedAt: Date.now(),

},

],

details: {

[input.sessionID]: {

sessionID: input.sessionID,

commits: input.commits,

},

},

permissions: [],

questions: [],

},

})

}

function wait(ms: number, signal?: AbortSignal): Promise<void> {

return new Promise((resolve) => {

if (!signal) {

setTimeout(resolve, ms)

return

}

if (signal.aborted) {

resolve()

return

}

const done = () => {

clearTimeout(timer)

signal.removeEventListener("abort", done)

resolve()

}

const timer = setTimeout(() => {

signal.removeEventListener("abort", done)

resolve()

}, ms)

signal.addEventListener("abort", done, { once: true })

})

}

function split(text: string): string[] {

if (text.length <= 48) {

return [text]

}

const size = Math.ceil(text.length / 3)

return [text.slice(0, size), text.slice(size, size * 2), text.slice(size * 2)]

}

function take(state: State, key: "msg" | "part" | "call" | "perm" | "ask", prefix: string): string {

state[key] += 1

return `demo_${prefix}_${state[key]}`

}

function feed(state: State, event: Event): void {

const out = reduceSessionData({

data: state.data,

event,

sessionID: state.id,

thinking: state.thinking,

limits: state.limits(),

})

state.data = out.data

writeSessionOutput(

{

footer: state.footer,

},

out,

)

}

function open(state: State): string {

const id = take(state, "msg", "msg")

feed(state, {

type: "message.updated",

properties: {

sessionID: state.id,

info: {

id,

sessionID: state.id,

role: "assistant",

time: {

created: Date.now(),

},

parentID: `user_${id}`,

modelID: "demo",

providerID: "demo",

mode: "demo",

agent: "demo",

path: {

cwd: process.cwd(),

root: process.cwd(),

},

cost: 0.001,

tokens: {

input: 120,

output: 320,

reasoning: 80,

cache: {

read: 0,

write: 0,

},

},

},

},

} as Event)

return id

}

async function emitText(state: State, body: string, signal?: AbortSignal): Promise<void> {

const msg = open(state)

const part = take(state, "part", "part")

const start = Date.now()

feed(state, {

type: "message.part.updated",

properties: {

sessionID: state.id,

time: Date.now(),

part: {

id: part,

sessionID: state.id,

messageID: msg,

type: "text",

text: "",

time: {

start,

},

},

},

} as Event)

let next = ""

for (const item of split(body)) {

if (signal?.aborted) {

return

}

next += item

feed(state, {

type: "message.part.delta",

properties: {

sessionID: state.id,

messageID: msg,

partID: part,

field: "text",

delta: item,

},

} as Event)

await wait(45, signal)

}

feed(state, {

type: "message.part.updated",

properties: {

sessionID: state.id,

time: Date.now(),

part: {

id: part,

sessionID: state.id,

messageID: msg,

type: "text",

text: next,

time: {

start,

end: Date.now(),

},

},

},

} as Event)

}

async function emitReasoning(state: State, body: string, signal?: AbortSignal): Promise<void> {

const msg = open(state)

const part = take(state, "part", "part")

const start = Date.now()

feed(state, {

type: "message.part.updated",

properties: {

sessionID: state.id,

time: Date.now(),

part: {

id: part,

sessionID: state.id,

messageID: msg,

type: "reasoning",

text: "",

time: {

start,

},

},

},

} as Event)

let next = ""

for (const item of split(body)) {

if (signal?.aborted) {

return

}

next += item

feed(state, {

type: "message.part.delta",

properties: {

sessionID: state.id,

messageID: msg,

partID: part,

field: "text",

delta: item,

},

} as Event)

await wait(45, signal)

}

feed(state, {

type: "message.part.updated",

properties: {

sessionID: state.id,

time: Date.now(),

part: {

id: part,

sessionID: state.id,

messageID: msg,

type: "reasoning",

text: next,

time: {

start,

end: Date.now(),

},

},

},

} as Event)

}

function make(state: State, tool: string, input: Record<string, unknown>): Ref {

return {

msg: open(state),

part: take(state, "part", "part"),

call: take(state, "call", "call"),

tool,

input,

start: Date.now(),

}

}

function startTool(state: State, ref: Ref, metadata: Record<string, unknown> = {}): void {

feed(state, {

type: "message.part.updated",

properties: {

sessionID: state.id,

time: Date.now(),

part: {

id: ref.part,

sessionID: state.id,

messageID: ref.msg,

type: "tool",

callID: ref.call,

tool: ref.tool,

state: {

status: "running",

input: ref.input,

metadata,

time: {

start: ref.start,

},

},

},

},

} as Event)

}

function askPermission(state: State, item: Permit): void {

startTool(state, item.ref)

const id = take(state, "perm", "perm")

state.perms.set(id, {

ref: item.ref,

done: item.done,

})

feed(state, {

type: "permission.asked",

properties: {

id,

sessionID: state.id,

permission: item.permission,

patterns: item.patterns,

metadata: item.metadata ?? {},

always: item.always,

tool: {

messageID: item.ref.msg,

callID: item.ref.call,

},

},

} as Event)

}

function doneTool(

state: State,

ref: Ref,

output: {

title: string

output: string

metadata?: Record<string, unknown>

},

): void {

feed(state, {

type: "message.part.updated",

properties: {

sessionID: state.id,

time: Date.now(),

part: {

id: ref.part,

sessionID: state.id,

messageID: ref.msg,

type: "tool",

callID: ref.call,

tool: ref.tool,

state: {

status: "completed",

input: ref.input,

output: output.output,

title: output.title,

metadata: output.metadata ?? {},

time: {

start: ref.start,

end: Date.now(),

},

},

},

},

} as Event)

}

function failTool(state: State, ref: Ref, error: string): void {

feed(state, {

type: "message.part.updated",

properties: {

sessionID: state.id,

time: Date.now(),

part: {

id: ref.part,

sessionID: state.id,

messageID: ref.msg,

type: "tool",

callID: ref.call,

tool: ref.tool,

state: {

status: "error",

input: ref.input,

error,

metadata: {},

time: {

start: ref.start,

end: Date.now(),

},

},

},

},

} as Event)

}

function emitError(state: State, text: string): void {

const event = {

id: `session.error:${state.id}:${Date.now()}`,

type: "session.error",

properties: {

sessionID: state.id,

error: {

name: "UnknownError",

data: {

message: text,

},

},

},

} satisfies Event

feed(state, event)

}

async function emitBash(state: State, signal?: AbortSignal): Promise<void> {

const ref = make(state, "bash", {

command: "git status",

workdir: process.cwd(),

description: "Show git status",

})

startTool(state, ref)

await wait(70, signal)

doneTool(state, ref, {

title: "git status",

output: `${process.cwd()}\ngit status\nOn branch demo\nnothing to commit, working tree clean\n`,

metadata: {

exitCode: 0,

},

})

}

function emitWrite(state: State): void {

const file = path.join(process.cwd(), "src", "demo-format.ts")

const ref = make(state, "write", {

filePath: file,

content: "export const demo = 42\n",

})

doneTool(state, ref, {

title: "write",

output: "",

metadata: {},

})

}

function emitEdit(state: State): void {

const file = path.join(process.cwd(), "src", "demo-format.ts")

const ref = make(state, "edit", {

filePath: file,

})

doneTool(state, ref, {

title: "edit",

output: "",

metadata: {

diff: "@@ -1 +1 @@\n-export const demo = 1\n+export const demo = 42\n",

},

})

}

function emitPatch(state: State): void {

const file = path.join(process.cwd(), "src", "demo-format.ts")

const ref = make(state, "apply_patch", {

patchText: "*** Begin Patch\n*** End Patch",

})

doneTool(state, ref, {

title: "apply_patch",

output: "",

metadata: {

files: [

{

type: "update",

filePath: file,

relativePath: "src/demo-format.ts",

diff: "@@ -1 +1 @@\n-export const demo = 1\n+export const demo = 42\n",

deletions: 1,

},

{

type: "add",

filePath: path.join(process.cwd(), "README-demo.md"),

relativePath: "README-demo.md",

diff: "@@ -0,0 +1,4 @@\n+# Demo\n+This is a generated preview file.\n",

deletions: 0,

},

],

},

})

}

function emitTask(state: State): void {

const ref = make(state, "task", {

description: "Scan run/* for reducer touchpoints",

subagent_type: "explore",

})

doneTool(state, ref, {

title: "Reducer touchpoints found",

output: "",

metadata: {

toolcalls: 4,

sessionId: "sub_demo_1",

},

})

const part = {

id: "sub_demo_tool_1",

type: "tool",

sessionID: "sub_demo_1",

messageID: "sub_demo_msg_tool",

callID: "sub_demo_call_1",

tool: "read",

state: {

status: "running",

input: {

filePath: "packages/opencode/src/cli/cmd/run/stream.ts",

offset: 1,

limit: 200,

},

time: {

start: Date.now(),

},

},

} satisfies ToolPart

showSubagent(state, {

sessionID: "sub_demo_1",

partID: ref.part,

callID: ref.call,

label: "Explore",

description: "Scan run/* for reducer touchpoints",

status: "completed",

title: "Reducer touchpoints found",

toolCalls: 4,

commits: [

{

kind: "user",

text: "Scan run/* for reducer touchpoints",

phase: "start",

source: "system",

},

{

kind: "reasoning",

text: "Thinking: tracing reducer and footer boundaries",

phase: "progress",

source: "reasoning",

messageID: "sub_demo_msg_reasoning",

partID: "sub_demo_reasoning_1",

},

{

kind: "tool",

text: "running read",

phase: "start",

source: "tool",

messageID: "sub_demo_msg_tool",

partID: "sub_demo_tool_1",

tool: "read",

part,

},

{

kind: "assistant",

text: "Footer updates flow through stream.ts into RunFooter",

phase: "progress",

source: "assistant",

messageID: "sub_demo_msg_text",

partID: "sub_demo_text_1",

},

],

})

}

function emitTodo(state: State): void {

const ref = make(state, "todowrite", {

todos: [

{

content: "Trigger permission UI",

status: "completed",

},

{

content: "Trigger question UI",

status: "in_progress",

},

{

content: "Tune tool formatting",

status: "pending",

},

],

})

doneTool(state, ref, {

title: "todowrite",

output: "",

metadata: {},

})

}

function emitQuestionTool(state: State): void {

const ref = make(state, "question", {

questions: [

{

header: "Style",

question: "Which output style do you want to inspect?",

options: [

{ label: "Diff", description: "Show diff block" },

{ label: "Code", description: "Show code block" },

],

multiple: false,

},

{

header: "Extras",

question: "Pick extra rows",

options: [

{ label: "Usage", description: "Add usage row" },

{ label: "Duration", description: "Add duration row" },

],

multiple: true,

custom: true,

},

],

})

doneTool(state, ref, {

title: "question",

output: "",

metadata: {

answers: [["Diff"], ["Usage", "custom-note"]],

},

})

}

function emitPermission(state: State, kind: PermissionKind = "edit"): void {

const root = process.cwd()

const file = path.join(root, "src", "demo-format.ts")

if (kind === "bash") {

const command = "git status --short"

const ref = make(state, "bash", {

command,

workdir: root,

description: "Inspect worktree changes",

})

askPermission(state, {

ref,

permission: "bash",

patterns: [command],

always: ["*"],

done: {

title: "git status --short",

output: `${root}\ngit status --short\n M src/demo-format.ts\n?? src/demo-permission.ts\n`,

metadata: {

exitCode: 0,

},

},

})

return

}

if (kind === "read") {

const target = path.join(root, "package.json")

const ref = make(state, "read", {

filePath: target,

offset: 1,

limit: 80,

})

askPermission(state, {

ref,

permission: "read",

patterns: [target],

always: [target],

done: {

title: "read",

output: ["1: {", '2: "name": "opencode",', '3: "private": true', "4: }"].join("\n"),

metadata: {},

},

})

return

}

if (kind === "task") {

const ref = make(state, "task", {

description: "Inspect footer spacing across direct-mode prompts",

subagent_type: "explore",

})

askPermission(state, {

ref,

permission: "task",

patterns: ["explore"],

always: ["*"],

done: {

title: "Footer spacing checked",

output: "",

metadata: {

toolcalls: 3,

sessionId: "sub_demo_perm_1",

},

},

})

return

}

if (kind === "external") {

const dir = path.join(path.dirname(root), "demo-shared")

const target = path.join(dir, "README.md")

const ref = make(state, "read", {

filePath: target,

offset: 1,

limit: 40,

})

askPermission(state, {

ref,

permission: "external_directory",

patterns: [`${dir}/**`],

metadata: {

parentDir: dir,

filepath: target,

},

always: [`${dir}/**`],

done: {

title: "read",

output: `1: # External demo\n2: Shared preview file\nPath: ${target}`,

metadata: {},

},

})

return

}

if (kind === "doom") {

const ref = make(state, "task", {

description: "Retry the formatter after repeated failures",

subagent_type: "general",

})

askPermission(state, {

ref,

permission: "doom_loop",

patterns: ["*"],

always: ["*"],

done: {

title: "Retry allowed",

output: "Continuing after repeated failures.\n",

metadata: {},

},

})

return

}

const diff = "@@ -1 +1 @@\n-export const demo = 1\n+export const demo = 42\n"

const ref = make(state, "edit", {

filePath: file,

filepath: file,

diff,

})

askPermission(state, {

ref,

permission: "edit",

patterns: [file],

always: [file],

done: {

title: "edit",

output: "",

metadata: {

diff,

},

},

})

}

function emitQuestion(state: State, kind: QuestionKind = "multi"): void {

const questions = (() => {

if (kind === "single") {

return [

{

header: "Mode",

question: "Which footer should be the reference for spacing checks?",

options: [

{ label: "Permission", description: "Inspect the permission footer" },

{ label: "Question", description: "Keep this question footer open" },

{ label: "Prompt", description: "Return to the normal composer" },

],

multiple: false,

custom: false,

},

]

}

if (kind === "checklist") {

return [

{

header: "Checks",

question: "Select the direct-mode cases you want to inspect next",

options: [

{ label: "Diff", description: "Show an edit diff in the footer" },

{ label: "Task", description: "Show a structured task summary" },

{ label: "Todo", description: "Show a todo snapshot" },

{ label: "Error", description: "Show an error transcript row" },

],

multiple: true,

custom: false,

},

]

}

if (kind === "custom") {

return [

{

header: "Reply",

question: "What custom answer should appear in the footer preview?",

options: [

{ label: "Short note", description: "Keep the answer to one line" },

{ label: "Wrapped note", description: "Use a longer answer to test wrapping" },

],

multiple: false,

custom: true,

},

]

}

return [

{

header: "Layout",

question: "Which footer view should stay active while testing?",

options: [

{ label: "Prompt", description: "Return to prompt" },

{ label: "Question", description: "Keep question open" },

],

multiple: false,

},

{

header: "Rows",

question: "Pick formatting previews",

options: [

{ label: "Diff", description: "Emit edit diff" },

{ label: "Task", description: "Emit task card" },

{ label: "Todo", description: "Emit todo card" },

],

multiple: true,

custom: true,

},

]