opencode-subagent-magazine 1.7.0 → 1.7.2

package/src/clipboard.ts

@@ -1,134 +0,0 @@
-import { spawn } from "node:child_process"
-import { platform, release } from "node:os"
-
-export type ClipboardMethod =
-  | "pbcopy"
-  | "osascript"
-  | "wl-copy"
-  | "xclip"
-  | "xsel"
-  | "powershell"
-  | "osc52"
-  | "none"
-
-export interface CopyTextResult {
-  copied: boolean
-  method: ClipboardMethod
-  error?: string
-}
-
-function runWithInput(command: string, args: string[], input: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      stdio: ["pipe", "ignore", "ignore"],
-      windowsHide: true,
-    })
-
-    child.once("error", reject)
-    child.once("close", (code) => {
-      if (code === 0) resolve()
-      else reject(new Error(`${command} exited with code ${code}`))
-    })
-
-    child.stdin?.end(input)
-  })
-}
-
-function writeOsc52(text: string): boolean {
-  if (!process.stdout.isTTY) return false
-
-  const payload = Buffer.from(text, "utf8").toString("base64")
-  const sequence = `\x1b]52;c;${payload}\x07`
-  const wrapped = process.env.TMUX || process.env.STY
-    ? `\x1bPtmux;\x1b${sequence}\x1b\\`
-    : sequence
-
-  process.stdout.write(wrapped)
-  return true
-}
-
-async function tryCommand(
-  method: ClipboardMethod,
-  command: string,
-  args: string[],
-  text: string,
-): Promise<CopyTextResult | undefined> {
-  try {
-    await runWithInput(command, args, text)
-    return { copied: true, method }
-  } catch {
-    return undefined
-  }
-}
-
-export async function copyText(text: string): Promise<CopyTextResult> {
-  if (!text) return { copied: false, method: "none", error: "empty_text" }
-
-  const os = platform()
-  const isWsl = release().toLowerCase().includes("microsoft")
-
-  const attempts: Array<() => Promise<CopyTextResult | undefined>> = []
-
-  if (os === "darwin") {
-    attempts.push(() => tryCommand("pbcopy", "pbcopy", [], text))
-    attempts.push(() =>
-      tryCommand(
-        "osascript",
-        "osascript",
-        ["-e", "set the clipboard to (read (POSIX file \"/dev/stdin\") as text)"],
-        text,
-      ),
-    )
-  }
-
-  if (os === "linux" && isWsl) {
-    attempts.push(() =>
-      tryCommand(
-        "powershell",
-        "powershell.exe",
-        [
-          "-NonInteractive",
-          "-NoProfile",
-          "-Command",
-          "[Console]::InputEncoding=[Text.Encoding]::UTF8; Set-Clipboard ([Console]::In.ReadToEnd())",
-        ],
-        text,
-      ),
-    )
-  } else if (os === "linux") {
-    if (process.env.WAYLAND_DISPLAY) {
-      attempts.push(() => tryCommand("wl-copy", "wl-copy", [], text))
-    }
-    attempts.push(() => tryCommand("xclip", "xclip", ["-selection", "clipboard"], text))
-    attempts.push(() => tryCommand("xsel", "xsel", ["--clipboard", "--input"], text))
-  }
-
-  if (os === "win32") {
-    attempts.push(() =>
-      tryCommand(
-        "powershell",
-        "powershell.exe",
-        [
-          "-NonInteractive",
-          "-NoProfile",
-          "-Command",
-          "[Console]::InputEncoding=[Text.Encoding]::UTF8; Set-Clipboard ([Console]::In.ReadToEnd())",
-        ],
-        text,
-      ),
-    )
-  }
-
-  for (const attempt of attempts) {
-    const result = await attempt()
-    if (result) return result
-  }
-
-  try {
-    if (writeOsc52(text)) return { copied: true, method: "osc52" }
-  } catch {
-    // Continue to the explicit failure result.
-  }
-
-  return { copied: false, method: "none", error: "clipboard_unavailable" }
-}

package/src/core/color.ts

@@ -1,70 +0,0 @@
-/** Morandi palette helpers — desaturate any theme color toward a muted fallback. */
-
-export function rgb(raw: unknown): { r: number; g: number; b: number } | null {
-  if (typeof raw === "string" && raw.startsWith("#")) {
-    const h = raw.slice(1)
-    return {
-      r: parseInt(h.slice(0, 2), 16),
-      g: parseInt(h.slice(2, 4), 16),
-      b: parseInt(h.slice(4, 6), 16),
-    }
-  }
-  if (raw && typeof raw === "object") {
-    const o = raw as Record<string, unknown>
-    if (typeof o.r === "number" && typeof o.g === "number" && typeof o.b === "number") {
-      const scale = o.r > 1 || o.g > 1 || o.b > 1 ? 1 : 255
-      return { r: Math.round(o.r * scale), g: Math.round(o.g * scale), b: Math.round(o.b * scale) }
-    }
-  }
-  return null
-}
-
-export function saturation(r: number, g: number, b: number): number {
-  const max = Math.max(r, g, b) / 255
-  const min = Math.min(r, g, b) / 255
-  const delta = max - min
-  if (delta === 0) return 0
-  const L = (max + min) / 2
-  return L <= 0.5 ? delta / (max + min) : delta / (2 - max - min)
-}
-
-function desaturateTo(raw: unknown, maxSat: number, fallback: string): string {
-  const c = rgb(raw)
-  if (!c) return fallback
-  const sat = saturation(c.r, c.g, c.b)
-  if (sat <= maxSat) {
-    return "#" + [c.r, c.g, c.b].map((v) => v.toString(16).padStart(2, "0")).join("")
-  }
-  const luma = c.r * 0.299 + c.g * 0.587 + c.b * 0.114
-  let lo = 0, hi = 1
-  for (let i = 0; i < 12; i++) {
-    const mid = (lo + hi) / 2
-    const nr = Math.round(c.r + (luma - c.r) * mid)
-    const ng = Math.round(c.g + (luma - c.g) * mid)
-    const nb = Math.round(c.b + (luma - c.b) * mid)
-    if (saturation(nr, ng, nb) > maxSat) lo = mid
-    else hi = mid
-  }
-  const nr = Math.round(c.r + (luma - c.r) * hi)
-  const ng = Math.round(c.g + (luma - c.g) * hi)
-  const nb = Math.round(c.b + (luma - c.b) * hi)
-  return "#" + [nr, ng, nb].map((v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join("")
-}
-
-function dimColor(hex: string, factor = 0.5): string {
-  const c = rgb(hex)
-  if (!c) return hex
-  const r = Math.round(c.r * factor)
-  const g = Math.round(c.g * factor)
-  const b = Math.round(c.b * factor)
-  return "#" + [r, g, b].map((v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join("")
-}
-
-export const FALLBACK = {
-  primary: "#8B9DAF", text: "#C5C5BB", muted: "#7A7A72",
-  success: "#9CAF8B", warning: "#C5B88D", error: "#B08A8A", border: "#6B6B63",
-} as const
-
-export const MAX_SAT = 0.28
-
-export { desaturateTo, dimColor }

package/src/core/format.ts

@@ -1,105 +0,0 @@
-import type { TimeFormat } from "./types"
-
-/** Visual width of a single character (CJK/wide chars count as 2). */
-function charColumns(c: string): number {
-  const code = c.codePointAt(0) ?? 0
-  if (code < 0x20) return 0
-  if (code < 0x7f) return 1
-  if (code < 0xa0) return 0
-  if (
-    (code >= 0x1100 && code <= 0x115f) ||
-    (code >= 0x2e80 && code <= 0xa4cf) ||
-    (code >= 0xac00 && code <= 0xd7a3) ||
-    (code >= 0xf900 && code <= 0xfaff) ||
-    (code >= 0xfe10 && code <= 0xfe6f) ||
-    (code >= 0xff01 && code <= 0xff60) ||
-    (code >= 0xffe0 && code <= 0xffe6) ||
-    (code >= 0x1f300 && code <= 0x1f64f) ||
-    (code >= 0x20000 && code <= 0x3fffd)
-  )
-    return 2
-  return 1
-}
-
-export function visualWidth(s: string): number {
-  let w = 0
-  for (const c of s) w += charColumns(c)
-  return w
-}
-
-export function truncate(text: string, maxCols: number): string {
-  if (visualWidth(text) <= maxCols) return text
-  let cols = 0
-  let i = 0
-  for (const c of text) {
-    const w = charColumns(c)
-    if (cols + w > maxCols - 1) break
-    cols += w
-    i += c.length
-  }
-  return text.slice(0, i) + "\u2026"
-}
-
-export function fmtDurationShort(ms: number, running: boolean): string {
-  if (running && ms < 2000) return ""
-  if (ms < 1000) return (ms / 1000).toFixed(2) + "s"
-  if (ms < 60000) return (ms / 1000).toFixed(2) + "s"
-  const m = Math.floor(ms / 60000)
-  const s = Math.round((ms % 60000) / 1000)
-  return `${m}m${s}s`
-}
-
-/** All supported elapsed-time display modes, in picker order. */
-export const TIME_FORMATS: readonly TimeFormat[] = ["short", "decimal", "clock", "compact", "seconds"]
-
-/** Neutral samples shown in the time-format picker (language independent). */
-export const TIME_FORMAT_SAMPLES: Record<TimeFormat, string> = {
-  decimal: "45.3s · 9.5m · 1.9h",
-  short: "45.32s · 112m35s",
-  clock: "0:45 · 1:52:35",
-  compact: "45s · 1h52m",
-  seconds: "45s · 6755s",
-}
-
-/** Formats elapsed milliseconds using the configured display mode. */
-export function fmtDuration(ms: number, running: boolean, mode: TimeFormat = "short"): string {
-  if (running && ms < 2000) return ""
-  const t = Number.isFinite(ms) && ms > 0 ? ms : 0
-  switch (mode) {
-    case "short":
-      return fmtDurationShort(t, false)
-    case "compact": {
-      if (t < 60000) return `${Math.floor(t / 1000)}s`
-      if (t < 3600000) return `${Math.floor(t / 60000)}m${Math.floor((t % 60000) / 1000)}s`
-      return `${Math.floor(t / 3600000)}h${Math.floor((t % 3600000) / 60000)}m`
-    }
-    case "clock": {
-      const s = Math.floor((t % 60000) / 1000)
-      if (t < 3600000) return `${Math.floor(t / 60000)}:${String(s).padStart(2, "0")}`
-      const m = Math.floor((t % 3600000) / 60000)
-      return `${Math.floor(t / 3600000)}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`
-    }
-    case "seconds":
-      return `${Math.floor(t / 1000)}s`
-    case "decimal":
-    default: {
-      // Promote units when rounding would show "60.0s" / "60.0m".
-      if (t < 59950) return `${(t / 1000).toFixed(1)}s`
-      if (t < 3597000) return `${(t / 60000).toFixed(1)}m`
-      return `${(t / 3600000).toFixed(1)}h`
-    }
-  }
-}
-
-export function fmtTokens(n: number): string {
-  if (n < 1000) return `${n}`
-  if (n < 1000000) return `${(n / 1000).toFixed(1)}k`
-  return `${(n / 1000000).toFixed(1)}M`
-}
-
-export function safeErrorMsg(err: unknown): string {
-  if (!err) return ""
-  if (typeof err === "string") return err
-  if (typeof err === "object") return String((err as any).message || (err as any).code || "")
-  return ""
-}

package/src/core/index.ts

@@ -1,6 +0,0 @@
-export * from "./types"
-export * from "./format"
-export * from "./color"
-export * from "./kv"
-export * from "./usage"
-export * from "./state-machine"

package/src/core/kv.ts

@@ -1,77 +0,0 @@
-import type { SessionRecord } from "./types"
-
-export const KV_PREFIX = "subagent_magazine"
-export const SESSION_DATA_KEY = `${KV_PREFIX}.session_data`
-
-/** Minimal KV surface used by the magazine's persistence layer. */
-export interface KVApi {
-  get(key: string, fallback?: unknown): unknown
-  set(key: string, value: unknown): void
-  /**
-   * Optional atomic read-modify-write. When the host exposes it (V2), the
-   * updater runs under the host storage lock against the latest on-disk value,
-   * which is what makes concurrent TUI instances safe: no instance can
-   * overwrite another one's fresh writes with a stale in-memory snapshot.
-   */
-  update?(key: string, updater: (current: unknown) => unknown): void | Promise<void>
-}
-
-/** Setting keys shared by V1/V2 (values are raw strings in KV). */
-export const SETTING_KEYS = {
-  lang: `${KV_PREFIX}.lang`,
-  maxEntries: `${KV_PREFIX}.max_entries`,
-  order: `${KV_PREFIX}.order`,
-  scrollMode: `${KV_PREFIX}.scroll_mode`,
-  open: `${KV_PREFIX}.open`,
-  ttlDays: `${KV_PREFIX}.ttl_days`,
-  border: `${KV_PREFIX}.border`,
-  showEntryCost: `${KV_PREFIX}.show_entry_cost`,
-  showEntryTime: `${KV_PREFIX}.show_entry_time`,
-  showEntryTokens: `${KV_PREFIX}.show_entry_tokens`,
-  timeFormat: `${KV_PREFIX}.time_format`,
-  dbSync: `${KV_PREFIX}.db_sync`,
-} as const
-
-export function loadSessionData(kv: KVApi): Record<string, SessionRecord> {
-  try {
-    const raw = kv.get(SESSION_DATA_KEY, "{}")
-    return JSON.parse(String(raw))
-  } catch { return {} }
-}
-
-/**
- * Atomic read-merge-write of the session store.
- *
- * `mutator` receives the latest persisted map (read under the host lock when
- * `kv.update` is available) and may mutate it freely; the result is written
- * back. Every writer must go through here: writing a whole in-memory snapshot
- * directly would silently drop entries created by the other TUIs.
- */
-export function updateSessionData(
-  kv: KVApi,
-  mutator: (data: Record<string, SessionRecord>) => void,
-): void | Promise<void> {
-  try {
-    if (typeof kv.update === "function") {
-      return kv.update(SESSION_DATA_KEY, (raw) => {
-        const data = parseSessionData(raw)
-        mutator(data)
-        return JSON.stringify(data)
-      })
-    }
-    // Fallback (V1 hosts without atomic update): read-modify-write. The window
-    // is small and the mutation is merged against the value we just read.
-    const data = loadSessionData(kv)
-    mutator(data)
-    kv.set(SESSION_DATA_KEY, JSON.stringify(data))
-  } catch {}
-}
-
-function parseSessionData(raw: unknown): Record<string, SessionRecord> {
-  try { return JSON.parse(String(raw ?? "{}")) } catch { return {} }
-}
-
-export function readTTLDays(kv: KVApi): number {
-  const ttlDaysRaw = parseInt(String(kv.get(SETTING_KEYS.ttlDays, "3")), 10)
-  return Number.isNaN(ttlDaysRaw) ? 3 : ttlDaysRaw
-}

package/src/core/state-machine.ts

@@ -1,46 +0,0 @@
-import type { SubEntry, SubStatus } from "./types"
-import type { TodoStats } from "./usage"
-
-/** Final status decision when a child session settles (V1 `session.idle` semantics). */
-export function settleOnIdle(entry: SubEntry): SubStatus {
-  if (entry.status === "cancel_requested" && entry.abortAccepted) return "cancelled"
-  return "done"
-}
-
-/** Agent-name normalization used by the fallback matching chain. */
-export function normalizeAgent(s: string): string {
-  return s.toLowerCase().replace(/[^a-z0-9-]/g, "")
-}
-
-/** Snapshot of usage values captured when a child session settles. */
-export interface SettleSnapshot {
-  tokens?: number
-  cost?: number
-  model?: string
-  todo?: TodoStats
-}
-
-/** Apply a settled status + usage backfill onto an entry (no-op preserving already-settled). */
-export function settleEntry(
-  entry: SubEntry,
-  targetStatus: SubStatus,
-  nowTs: number,
-  snap: SettleSnapshot,
-  errorMsg?: string,
-): SubEntry {
-  const alreadySettled = entry.status !== "running" && entry.status !== "cancel_requested"
-  const finalStatus = targetStatus === "error" ? "error" : settleOnIdle(entry)
-  return {
-    ...entry,
-    ...(alreadySettled ? {} : { status: finalStatus, endedAt: nowTs }),
-    tokens: entry.tokens ?? snap.tokens,
-    cost: entry.cost ?? snap.cost,
-    model: entry.model ?? snap.model,
-    todoTotal: entry.todoTotal ?? snap.todo?.total,
-    todoDone: entry.todoDone ?? snap.todo?.done,
-    error: errorMsg || entry.error,
-  }
-}
-
-/** Time-based scan heuristic: how old must a running entry be before assuming completion. */
-export const STALE_RUNNING_MS = 30 * 60 * 1000

package/src/core/types.ts

@@ -1,72 +0,0 @@
-import type { LangCode } from "../i18n"
-
-export type SubStatus = "running" | "done" | "error" | "cancel_requested" | "cancelled"
-
-export interface SubEntry {
-  id: string
-  title: string
-  agent: string
-  prompt: string
-  error?: string
-  tokens?: number
-  cost?: number
-  status: SubStatus
-  sessionId?: string
-  startedAt: number
-  endedAt?: number
-  model?: string
-  todoTotal?: number
-  todoDone?: number
-  cancelRequestedAt?: number
-  abortAccepted?: boolean
-  cancelReason?: "manual"
-}
-
-export type Lang = LangCode
-export type SortOrder = "desc" | "asc"
-export type ScrollMode = "wheel" | "click"
-/** How elapsed time is rendered in the sidebar (see TIME_FORMAT_SAMPLES). */
-export type TimeFormat = "decimal" | "short" | "clock" | "compact" | "seconds"
-
-/** OpenCode built-in tool names that spawn sub-agents or delegate tasks. */
-export const SUBAGENT_TOOLS = new Set(["task", "subagent", "delegate", "call_omo_agent"])
-
-export interface ChildRecord {
-  scroll: number
-  expanded: string
-  entries: SubEntry[]
-  clearedIds?: string[]
-}
-
-export interface SessionRecord {
-  ts: number
-  entries: SubEntry[]
-  scroll: number
-  expanded: string
-  children: Record<string, ChildRecord>
-  clearedIds?: string[]
-}
-
-export interface SharedSignals {
-  lang: () => Lang
-  setLang: (l: Lang) => void
-  maxEntries: () => number
-  setMaxEntries: (n: number) => void
-  sortOrder: () => SortOrder
-  setSortOrder: (o: SortOrder) => void
-  scrollMode: () => ScrollMode
-  setScrollMode: (m: ScrollMode) => void
-  borderVisible: () => boolean
-  setBorderVisible: (v: boolean) => void
-  showEntryCost: () => boolean
-  setShowEntryCost: (v: boolean) => void
-  showEntryTime: () => boolean
-  setShowEntryTime: (v: boolean) => void
-  showEntryTokens: () => boolean
-  setShowEntryTokens: (v: boolean) => void
-  timeFormat: () => TimeFormat
-  setTimeFormat: (f: TimeFormat) => void
-  dbSync: () => boolean
-  setDbSync: (v: boolean) => void
-  sessionId: string
-}

package/src/core/usage.ts

@@ -1,16 +0,0 @@
-export interface TodoStats {
-  total: number
-  done: number
-}
-
-/**
- * Data-source abstraction for per-session usage reads.
- * V1 and V2 provide their own implementations backed by their respective
- * client APIs; the state machine consumes only this surface.
- */
-export interface UsageReader {
-  readSessionTokens(sid: string): number | undefined
-  readSessionCost(sid: string): number | undefined
-  readSessionModel(sid: string): string | undefined
-  readSessionTodo(sid: string): TodoStats | undefined
-}