saeeol 1.4.2 → 1.4.3

package/src/cli/cmd/run-events.ts

@@ -1,149 +0,0 @@
-import { EOL } from "os"
-import type { Part } from "@saeeol/sdk/v2"
-import type { SaeeolClient } from "@saeeol/sdk/v2"
-import { expDelay } from "@/boxes/schedule"
-import { SaeeolRunAuto } from "@/saeeol/cli/run-auto"
-import { UI } from "../ui"
-import { displayTool, displayTask, inline } from "./run-display"
-
-type EventLoopDeps = {
-  sdk: SaeeolClient
-  sessionID: string
-  format: string
-  thinking: boolean
-  auto: ReturnType<typeof SaeeolRunAuto.create>
-}
-
-export function emitJSON(type: string, data: Record<string, unknown>, sessionID: string) {
-  process.stdout.write(JSON.stringify({ type, timestamp: Date.now(), sessionID, ...data }) + EOL)
-}
-
-export async function runEventLoop(deps: EventLoopDeps) {
-  const { sdk, sessionID, format, thinking, auto } = deps
-  const events = await sdk.event.subscribe()
-  const toggles = new Map<string, boolean>()
-  const MAX_RETRIES = 3
-  let retries = 0
-  let error: string | undefined
-  const isJSON = format === "json"
-
-  for await (const event of events.stream) {
-    if (
-      event.type === "message.updated" &&
-      event.properties.info.role === "assistant" &&
-      !isJSON &&
-      !toggles.get("start")
-    ) {
-      UI.empty()
-      UI.println(`> ${event.properties.info.agent} · ${event.properties.info.modelID}`)
-      UI.empty()
-      toggles.set("start", true)
-    }
-
-    if (event.type === "message.part.updated") {
-      const part = event.properties.part as Part
-      SaeeolRunAuto.track(auto, part)
-      if (part.sessionID !== sessionID) continue
-
-      if (part.type === "tool" && (part.state.status === "completed" || part.state.status === "error")) {
-        if (isJSON) { emitJSON("tool_use", { part }, sessionID); continue }
-        if (part.state.status === "completed") { displayTool(part); continue }
-        inline({ icon: "✗", title: `${part.tool} failed` })
-        UI.error(part.state.error)
-        continue
-      }
-
-      if (part.type === "tool" && part.tool === "task" && part.state.status === "running" && !isJSON) {
-        if (toggles.get(part.id)) continue
-        displayTask(part)
-        toggles.set(part.id, true)
-        continue
-      }
-
-      if (part.type === "step-start") {
-        if (isJSON) { emitJSON("step_start", { part }, sessionID); continue }
-      }
-
-      if (part.type === "step-finish") {
-        if (isJSON) { emitJSON("step_finish", { part }, sessionID); continue }
-      }
-
-      if (part.type === "text" && part.time?.end) {
-        if (isJSON) { emitJSON("text", { part }, sessionID); continue }
-        const text = part.text.trim()
-        if (!text) continue
-        if (!process.stdout.isTTY) { process.stdout.write(text + EOL); continue }
-        UI.empty()
-        UI.println(text)
-        UI.empty()
-        continue
-      }
-
-      if (part.type === "reasoning" && part.time?.end && thinking) {
-        if (isJSON) { emitJSON("reasoning", { part }, sessionID); continue }
-        const text = part.text.trim()
-        if (!text) continue
-        const line = `Thinking: ${text}`
-        if (process.stdout.isTTY) {
-          UI.empty()
-          UI.println(`${UI.Style.TEXT_DIM}\u001b[3m${line}\u001b[0m${UI.Style.TEXT_NORMAL}`)
-          UI.empty()
-          continue
-        }
-        process.stdout.write(line + EOL)
-      }
-    }
-
-    if (event.type === "session.error") {
-      const props = event.properties
-      if (props.sessionID !== sessionID || !props.error) continue
-      let err = String(props.error.name)
-      if ("data" in props.error && props.error.data && "message" in props.error.data) {
-        err = String(props.error.data.message)
-      }
-      error = error ? error + EOL + err : err
-      if (isJSON) { emitJSON("error", { error: props.error }, sessionID); continue }
-      UI.error(err)
-    }
-
-    if (event.type === "session.status" && event.properties.sessionID === sessionID) {
-      if (event.properties.status.type === "busy") retries = 0
-      if (event.properties.status.type === "idle") break
-    }
-
-    if (event.type === "permission.asked") {
-      const permission = event.properties
-      if (auto) {
-        if (!SaeeolRunAuto.allowed(auto, permission.sessionID)) continue
-        await sdk.permission.reply({ requestID: permission.id, reply: "once" })
-        continue
-      }
-      if (permission.sessionID !== sessionID) continue
-      UI.println(
-        UI.Style.TEXT_WARNING_BOLD + "!",
-        UI.Style.TEXT_NORMAL +
-          `permission requested: ${permission.permission} (${permission.patterns.join(", ")}); auto-rejecting`,
-      )
-      await sdk.permission.reply({ requestID: permission.id, reply: "reject" })
-    }
-
-    if (event.type === "session.network.asked") {
-      const request = event.properties
-      if (request.sessionID !== sessionID) continue
-      retries++
-      if (retries > MAX_RETRIES) {
-        UI.println(
-          UI.Style.TEXT_WARNING_BOLD + "!",
-          UI.Style.TEXT_NORMAL + `network retry limit reached (${MAX_RETRIES}); rejecting`,
-        )
-        await sdk.network.reject({ requestID: request.id })
-        continue
-      }
-      const delay = Math.min(expDelay(5000, retries - 1), 60_000)
-      await new Promise((r) => setTimeout(r, delay))
-      await sdk.network.reply({ requestID: request.id })
-    }
-  }
-
-  return error
-}

package/src/cli/cmd/run-session.ts

@@ -1,143 +0,0 @@
-import type { SaeeolClient } from "@saeeol/sdk/v2"
-import { Flag } from "@saeeol/core/flag/flag"
-import { Agent } from "@/agent/agent"
-import { AppRuntime } from "@/effect/app-runtime"
-import { UI } from "../ui"
-import { importCloudSession, validateCloudFork } from "@/saeeol/cloud-session"
-import { SaeeolRunAuto } from "@/saeeol/cli/run-auto"
-
-export type SessionDeps = {
-  sdk: SaeeolClient
-  args: {
-    continue?: boolean
-    session?: string
-    cloudFork?: boolean
-    fork?: boolean
-    title?: string
-    share?: boolean
-    model?: string
-    agent?: string
-    variant?: string
-    attach?: string
-    command?: string
-    format: string
-    thinking: boolean
-    auto: boolean
-  }
-  message: string
-}
-
-export async function resolveSessionID(
-  sdk: SaeeolClient,
-  opts: { continue?: boolean; session?: string; cloudFork?: boolean; fork?: boolean; title?: string; message: string },
-) {
-  const rules = [
-    { permission: "question", action: "deny", pattern: "*" },
-    { permission: "plan_enter", action: "deny", pattern: "*" },
-    { permission: "plan_exit", action: "deny", pattern: "*" },
-  ]
-  const baseID = opts.continue
-    ? (await sdk.session.list()).data?.find((s) => !s.parentID)?.id
-    : opts.session
-
-  if (baseID && opts.cloudFork) {
-    const id = await importCloudSession(sdk, baseID).catch(() => undefined)
-    if (!id) { UI.error("Failed to import session from cloud"); process.exit(1) }
-    return id
-  }
-
-  if (baseID && opts.fork) {
-    const forked = await sdk.session.fork({ sessionID: baseID })
-    return forked.data?.id
-  }
-
-  if (baseID) return baseID
-
-  const title = (() => {
-    if (opts.title === undefined) return undefined
-    if (opts.title !== "") return opts.title
-    return opts.message.slice(0, 50) + (opts.message.length > 50 ? "..." : "")
-  })()
-
-  const result = await sdk.session.create({ title, permission: rules as any })
-  return result.data?.id
-}
-
-export async function shareSession(sdk: SaeeolClient, sessionID: string, shouldShare?: boolean) {
-  const cfg = await sdk.config.get()
-  if (!cfg.data) return
-  if (cfg.data.share !== "auto" && !Flag.SAEEOL_AUTO_SHARE && !shouldShare) return
-  const res = await sdk.session.share({ sessionID }).catch((error) => {
-    if (error instanceof Error && error.message.includes("disabled")) {
-      UI.println(UI.Style.TEXT_DANGER_BOLD + "!  " + error.message)
-    }
-    return { error }
-  })
-  if (!res.error && "data" in res && res.data?.share?.url) {
-    UI.println(UI.Style.TEXT_INFO_BOLD + "~  " + res.data.share.url)
-  }
-}
-
-export async function resolveAgent(
-  sdk: SaeeolClient | undefined,
-  name: string | undefined,
-  attach: string | undefined,
-) {
-  if (!name) return undefined
-
-  if (attach && sdk) {
-    const modes = await sdk.app
-      .agents(undefined, { throwOnError: true })
-      .then((x) => x.data ?? [])
-      .catch(() => undefined)
-
-    if (!modes) {
-      UI.println(
-        UI.Style.TEXT_WARNING_BOLD + "!",
-        UI.Style.TEXT_NORMAL,
-        `failed to list agents from ${attach}. Falling back to default agent`,
-      )
-      return undefined
-    }
-
-    const agent = modes.find((a) => a.name === name)
-    if (!agent) {
-      UI.println(
-        UI.Style.TEXT_WARNING_BOLD + "!",
-        UI.Style.TEXT_NORMAL,
-        `agent "${name}" not found. Falling back to default agent`,
-      )
-      return undefined
-    }
-
-    if (agent.mode === "subagent") {
-      UI.println(
-        UI.Style.TEXT_WARNING_BOLD + "!",
-        UI.Style.TEXT_NORMAL,
-        `agent "${name}" is a subagent, not a primary agent. Falling back to default agent`,
-      )
-      return undefined
-    }
-
-    return name
-  }
-
-  const entry = await AppRuntime.runPromise(Agent.Service.use((svc) => svc.get(name)))
-  if (!entry) {
-    UI.println(
-      UI.Style.TEXT_WARNING_BOLD + "!",
-      UI.Style.TEXT_NORMAL,
-      `agent "${name}" not found. Falling back to default agent`,
-    )
-    return undefined
-  }
-  if (entry.mode === "subagent") {
-    UI.println(
-      UI.Style.TEXT_WARNING_BOLD + "!",
-      UI.Style.TEXT_NORMAL,
-      `agent "${name}" is a subagent, not a primary agent. Falling back to default agent`,
-    )
-    return undefined
-  }
-  return name
-}

package/src/cli/cmd/run.ts

@@ -1,135 +0,0 @@
-import type { Argv } from "yargs"
-import path from "path"
-import { pathToFileURL } from "url"
-import { text as streamText } from "node:stream/consumers"
-import { Filesystem } from "@/util/filesystem"
-import { createSaeeolClient } from "@saeeol/sdk/v2"
-import { Server } from "../../server/server"
-import { Provider } from "@/provider/provider"
-import { bootstrap } from "../bootstrap"
-import { UI } from "../ui"
-import { cmd } from "./cmd"
-import { validateCloudFork } from "@/saeeol/cloud-session"
-import { SaeeolRunAuto } from "@/saeeol/cli/run-auto"
-import { resolveSessionID, shareSession, resolveAgent } from "./run-session"
-import { runEventLoop } from "./run-events"
-
-export const RunCommand = cmd({
-  command: "run [message..]",
-  describe: "run saeeol with a message",
-  builder: (yargs: Argv) => {
-    return (
-      yargs
-        .positional("message", { describe: "message to send", type: "string", array: true, default: [] })
-        .option("command", { describe: "the command to run, use message for args", type: "string" })
-        .option("continue", { alias: ["c"], describe: "continue the last session", type: "boolean" })
-        .option("session", { alias: ["s"], describe: "session id to continue", type: "string" })
-        .option("fork", { describe: "fork before continuing (requires --continue or --session)", type: "boolean" })
-        .option("share", { type: "boolean", describe: "share the session" })
-        .option("model", { type: "string", alias: ["m"], describe: "model (provider/model)" })
-        .option("agent", { type: "string", describe: "agent to use" })
-        .option("format", { type: "string", choices: ["default", "json"], default: "default", describe: "output format" })
-        .option("file", { alias: ["f"], type: "string", array: true, describe: "file(s) to attach" })
-        .option("title", { type: "string", describe: "title for the session" })
-        .option("attach", { type: "string", describe: "attach to a running saeeol server" })
-        .option("password", { alias: ["p"], type: "string", describe: "basic auth password" })
-        .option("dir", { type: "string", describe: "directory to run in" })
-        .option("port", { type: "number", describe: "port for the local server" })
-        .option("variant", { type: "string", describe: "model variant (reasoning effort)" })
-        .option("thinking", { type: "boolean", describe: "show thinking blocks", default: false })
-        .option("auto", { type: "boolean", describe: "auto-approve all permissions", default: false })
-    )
-  },
-  handler: async (args) => {
-    let message = [...args.message, ...(args["--"] || [])]
-      .map((arg) => (arg.includes(" ") ? `"${arg.replace(/"/g, '\\"')}"` : arg))
-      .join(" ")
-
-    const directory = (() => {
-      if (!args.dir) return undefined
-      if (args.attach) return args.dir
-      try { process.chdir(args.dir); return process.cwd() }
-      catch { UI.error("Failed to change directory to " + args.dir); process.exit(1) }
-    })()
-
-    const files = await resolveFiles(args.file)
-    if (!process.stdin.isTTY) message += "\n" + (await streamText(process.stdin))
-    if (message.trim().length === 0 && !args.command) {
-      UI.error("You must provide a message or a command"); process.exit(1)
-    }
-    if (args.fork && !args.continue && !args.session) {
-      UI.error("--fork requires --continue or --session"); process.exit(1)
-    }
-    const cloudForkError = validateCloudFork(args)
-    if (cloudForkError) { UI.error(cloudForkError); process.exit(1) }
-
-    async function execute(sdk: ReturnType<typeof createSaeeolClient>) {
-      const sessionID = await resolveSessionID(sdk, {
-        continue: args.continue,
-        session: args.session,
-        cloudFork: args.cloudFork as boolean | undefined,
-        fork: args.fork,
-        title: args.title,
-        message,
-      })
-      if (!sessionID) { UI.error("Session not found"); process.exit(1) }
-
-      const auto = SaeeolRunAuto.create(sessionID)
-      await shareSession(sdk, sessionID, args.share)
-      const agent = await resolveAgent(args.attach ? sdk : undefined, args.agent, args.attach)
-
-      runEventLoop({ sdk, sessionID, format: args.format, thinking: args.thinking, auto }).catch((e) => {
-        console.error(e); process.exit(1)
-      })
-
-      if (args.command) {
-        await sdk.session.command({
-          sessionID, agent, model: args.model, command: args.command,
-          arguments: message, variant: args.variant,
-        })
-      } else {
-        const model = args.model ? Provider.parseModel(args.model) : undefined
-        await sdk.session.prompt({
-          sessionID, agent, model, variant: args.variant,
-          parts: [...files, { type: "text", text: message }],
-        })
-      }
-    }
-
-    if (args.attach) {
-      const headers = buildAuthHeaders(args.password)
-      const sdk = createSaeeolClient({ baseUrl: args.attach, directory, headers })
-      return await execute(sdk)
-    }
-
-    await bootstrap(process.cwd(), async () => {
-      const fetchFn = (async (input: RequestInfo | URL, init?: RequestInit) => {
-        const request = new Request(input, init)
-        return Server.Default().app.fetch(request)
-      }) as typeof globalThis.fetch
-      const sdk = createSaeeolClient({ baseUrl: "http://saeeol.internal", fetch: fetchFn })
-      await execute(sdk)
-    })
-  },
-})
-
-function buildAuthHeaders(password?: string) {
-  const pw = password ?? process.env.SAEEOL_SERVER_PASSWORD
-  if (!pw) return undefined
-  const username = process.env.SAEEOL_SERVER_USERNAME ?? "saeeol"
-  const auth = `Basic ${Buffer.from(`${username}:${pw}`).toString("base64")}`
-  return { Authorization: auth }
-}
-
-async function resolveFiles(fileArgs: string | string[] | undefined) {
-  if (!fileArgs) return []
-  const list = Array.isArray(fileArgs) ? fileArgs : [fileArgs]
-  const files: { type: "file"; url: string; filename: string; mime: string }[] = []
-  for (const filePath of list) {
-    const resolved = path.resolve(process.cwd(), filePath)
-    if (!(await Filesystem.exists(resolved))) { UI.error(`File not found: ${filePath}`); process.exit(1) }
-    const mime = (await Filesystem.isDir(resolved)) ? "application/x-directory" : "text/plain"
-    files.push({ type: "file", url: pathToFileURL(resolved).href, filename: path.basename(resolved), mime })
-  }
-  return files
-}

package/src/cli/cmd/serve.ts

@@ -1,32 +0,0 @@
-import { Server } from "../../server/server"
-import { cmd } from "./cmd"
-import { withNetworkOptions, resolveNetworkOptions } from "../network"
-import { Flag } from "@saeeol/core/flag/flag"
-import { InstanceStore } from "../../project/instance-store" 
-
-export const ServeCommand = cmd({
-  command: "serve",
-  builder: (yargs) => withNetworkOptions(yargs),
-  describe: "starts a headless saeeol server", 
-  handler: async (args) => {
-    if (!Flag.SAEEOL_SERVER_PASSWORD) {
-      console.log("Warning: SAEEOL_SERVER_PASSWORD is not set; server is unsecured.")
-    }
-    const opts = await resolveNetworkOptions(args)
-    const server = await Server.listen(opts)
-    console.log(`saeeol server listening on http://${server.hostname}:${server.port}`)
-    const abort = new AbortController()
-    const shutdown = async () => {
-      try {
-        await InstanceStore.disposeAllInstances()
-        await server.stop(true)
-      } finally {
-        abort.abort()
-      }
-    }
-    process.on("SIGTERM", shutdown)
-    process.on("SIGINT", shutdown)
-    process.on("SIGHUP", shutdown)
-    await new Promise((resolve) => abort.signal.addEventListener("abort", resolve))
-  },
-})

package/src/cli/cmd/session.ts

@@ -1,216 +0,0 @@
-import type { Argv } from "yargs"
-import { cmd } from "./cmd"
-import { Session } from "@/session/session"
-import { SessionID } from "../../session/schema"
-import { bootstrap } from "../bootstrap"
-import { UI } from "../ui"
-import { Locale } from "@/util/locale"
-import { Flag } from "@saeeol/core/flag/flag"
-import { Filesystem } from "@/util/filesystem"
-import { Process } from "@/util/process"
-import { EOL } from "os"
-import path from "path"
-import { which } from "../../util/which"
-import { AppRuntime } from "@/effect/app-runtime"
-
-function pagerCmd(): string[] {
-  const lessOptions = ["-R", "-S"]
-  if (process.platform !== "win32") {
-    return ["less", ...lessOptions]
-  }
-
-  // user could have less installed via other options
-  const lessOnPath = which("less")
-  if (lessOnPath) {
-    if (Filesystem.stat(lessOnPath)?.size) return [lessOnPath, ...lessOptions]
-  }
-
-  if (Flag.SAEEOL_GIT_BASH_PATH) {
-    const less = path.join(Flag.SAEEOL_GIT_BASH_PATH, "..", "..", "usr", "bin", "less.exe")
-    if (Filesystem.stat(less)?.size) return [less, ...lessOptions]
-  }
-
-  const git = which("git")
-  if (git) {
-    const less = path.join(git, "..", "..", "usr", "bin", "less.exe")
-    if (Filesystem.stat(less)?.size) return [less, ...lessOptions]
-  }
-
-  // Fall back to Windows built-in more (via cmd.exe)
-  return ["cmd", "/c", "more"]
-}
-
-export const SessionCommand = cmd({
-  command: "session",
-  describe: "manage sessions",
-  builder: (yargs: Argv) => yargs.command(SessionListCommand).command(SessionDeleteCommand).demandCommand(),
-  async handler() {},
-})
-
-export const SessionDeleteCommand = cmd({
-  command: "delete <sessionID>",
-  describe: "delete a session",
-  builder: (yargs: Argv) => {
-    return yargs.positional("sessionID", {
-      describe: "session ID to delete",
-      type: "string",
-      demandOption: true,
-    })
-  },
-  handler: async (args) => {
-    await bootstrap(process.cwd(), async () => {
-      const sessionID = SessionID.make(args.sessionID)
-      try {
-        await AppRuntime.runPromise(Session.Service.use((svc) => svc.get(sessionID)))
-      } catch {
-        UI.error(`Session not found: ${args.sessionID}`)
-        process.exit(1)
-      }
-      await AppRuntime.runPromise(Session.Service.use((svc) => svc.remove(sessionID)))
-      UI.println(UI.Style.TEXT_SUCCESS_BOLD + `Session ${args.sessionID} deleted` + UI.Style.TEXT_NORMAL)
-    })
-  },
-})
-
-export const SessionListCommand = cmd({
-  command: "list",
-  describe: "list sessions",
-  builder: (yargs: Argv) => {
-    return (
-      yargs
-        .option("max-count", {
-          alias: "n",
-          describe: "limit to N most recent sessions",
-          type: "number",
-        })
-        .option("format", {
-          describe: "output format",
-          type: "string",
-          choices: ["table", "json"],
-          default: "table",
-        })
-        .option("all", {
-          alias: "a",
-          describe: "list sessions from all projects",
-          type: "boolean",
-          default: false,
-        })
-        .option("search", {
-          alias: "s",
-          describe: "filter sessions by title",
-          type: "string",
-        })
-    )
-  },
-  handler: async (args) => {
-    await bootstrap(process.cwd(), async () => {
-      const sessions = args.all
-        ? [...Session.listGlobal({ roots: true, limit: args.maxCount, search: args.search })]
-        : await AppRuntime.runPromise(
-            Session.Service.use((svc) => svc.list({ roots: true, limit: args.maxCount, search: args.search })),
-          )
-      if (sessions.length === 0) {
-        return
-      }
-      let output: string
-      if (args.format === "json") {
-        output = args.all
-          ? formatGlobalSessionJSON(sessions as Session.GlobalInfo[])
-          : formatSessionJSON(sessions as Session.Info[])
-      } else {
-        output = args.all
-          ? formatGlobalSessionTable(sessions as Session.GlobalInfo[])
-          : formatSessionTable(sessions as Session.Info[])
-      }
-
-      const shouldPaginate = process.stdout.isTTY && !args.maxCount && args.format === "table"
-
-      if (shouldPaginate) {
-        const proc = Process.spawn(pagerCmd(), {
-          stdin: "pipe",
-          stdout: "inherit",
-          stderr: "inherit",
-        })
-
-        if (!proc.stdin) {
-          console.log(output)
-          return
-        }
-
-        proc.stdin.write(output)
-        proc.stdin.end()
-        await proc.exited
-      } else {
-        console.log(output)
-      }
-    })
-  },
-})
-
-function formatSessionTable(sessions: Session.Info[]): string {
-  const lines: string[] = []
-
-  const maxIdWidth = Math.max(20, ...sessions.map((s) => s.id.length))
-  const maxTitleWidth = Math.max(25, ...sessions.map((s) => s.title.length))
-
-  const header = `Session ID${" ".repeat(maxIdWidth - 10)}  Title${" ".repeat(maxTitleWidth - 5)}  Updated`
-  lines.push(header)
-  lines.push("─".repeat(header.length))
-  for (const session of sessions) {
-    const truncatedTitle = Locale.truncate(session.title, maxTitleWidth)
-    const timeStr = Locale.todayTimeOrDateTime(session.time.updated)
-    const line = `${session.id.padEnd(maxIdWidth)}  ${truncatedTitle.padEnd(maxTitleWidth)}  ${timeStr}`
-    lines.push(line)
-  }
-
-  return lines.join(EOL)
-}
-function formatSessionJSON(sessions: Session.Info[]): string {
-  const jsonData = sessions.map((session) => ({
-    id: session.id,
-    title: session.title,
-    updated: session.time.updated,
-    created: session.time.created,
-    projectId: session.projectID,
-    directory: session.directory,
-  }))
-  return JSON.stringify(jsonData, null, 2)
-}
-function formatGlobalSessionTable(sessions: Session.GlobalInfo[]): string {
-  const lines: string[] = []
-
-  const maxIdWidth = Math.max(20, ...sessions.map((s) => s.id.length))
-  const maxTitleWidth = Math.max(25, ...sessions.map((s) => s.title.length))
-  const maxProjectWidth = Math.max(
-    10,
-    ...sessions.map((s) => (s.project?.name ?? s.project?.worktree ?? "unknown").length),
-  )
-
-  const header = `Session ID${" ".repeat(maxIdWidth - 10)}  Title${" ".repeat(maxTitleWidth - 5)}  Project${" ".repeat(maxProjectWidth - 7)}  Updated`
-  lines.push(header)
-  lines.push("─".repeat(header.length))
-  for (const session of sessions) {
-    const truncatedTitle = Locale.truncate(session.title, maxTitleWidth)
-    const project = Locale.truncate(session.project?.name ?? session.project?.worktree ?? "unknown", maxProjectWidth)
-    const timeStr = Locale.todayTimeOrDateTime(session.time.updated)
-    const line = `${session.id.padEnd(maxIdWidth)}  ${truncatedTitle.padEnd(maxTitleWidth)}  ${project.padEnd(maxProjectWidth)}  ${timeStr}`
-    lines.push(line)
-  }
-
-  return lines.join(EOL)
-}
-
-function formatGlobalSessionJSON(sessions: Session.GlobalInfo[]): string {
-  const jsonData = sessions.map((session) => ({
-    id: session.id,
-    title: session.title,
-    updated: session.time.updated,
-    created: session.time.created,
-    projectId: session.projectID,
-    directory: session.directory,
-    project: session.project
-      ? { id: session.project.id, name: session.project.name, worktree: session.project.worktree }
-      : null,
-  }))
-  return JSON.stringify(jsonData, null, 2)
-}