saeeol 1.1.0 → 1.1.1

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

@@ -0,0 +1,149 @@
+import { EOL } from "os"
+import type { Part } from "@saeeol/sdk/v2"
+import type { SaeeolClient } from "@saeeol/sdk/v2"
+import { expDelay } from "@saeeol/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

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,216 @@
+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)
+}