@chatcode/cco-better-sidebar 0.18.0-alpha.0

package/src/ui-tweaks/turn-outcome.ts

@@ -0,0 +1,105 @@
+/**
+ * dsh-ui-tweaks — turn outcome projection (host half).
+ *
+ * Registers the `dshTurnOutcome` session projection unit: the outcome of the
+ * session's most recent agent turn, folded from the log's `turn/end` events.
+ * The task notifier reads it off each sessions-list row (`projectionValues`)
+ * so it can announce WHY a turn ended — completed vs user-aborted vs failed —
+ * instead of announcing every running-drop as a plain finish.
+ *
+ * Whole-value rule: every `turn/end` replaces the previous value outright
+ * (last-wins), and `null` means no completed turn yet. Error turns keep a
+ * truncated copy of the structured failure message for notification bodies.
+ *
+ * `TurnEndReason` is merge-extensible upstream; unknown future kinds flow
+ * through as their literal kind string and the client falls back to a generic
+ * finish announcement.
+ * @module dsh-ui-tweaks/turn-outcome
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection'
+import type { ZodType } from 'zod'
+
+/** Projection key the browser notifier reads through list-row `projectionValues`. */
+export const TURN_OUTCOME_PROJECTION_KEY = 'dshTurnOutcome'
+
+/** The stock `TurnEndReason` kinds (the map is merge-extensible upstream). */
+export type TurnOutcomeKind = 'completed' | 'aborted' | 'blocked' | 'error' | 'max-tokens' | 'interrupted'
+
+/** Whole projection value: why the latest turn ended. */
+export interface TurnOutcomeValue {
+  kind: TurnOutcomeKind
+  /** Unix epoch ms of the `turn/end` event. */
+  time: number
+  /** Turn number carried by the same event. */
+  turn?: number
+  /** Truncated human-readable failure text; present only on `error` outcomes. */
+  errorMessage?: string
+}
+
+/** Cap the embedded error message so projection payloads stay small. */
+const MAX_ERROR_CHARS = 160
+
+/**
+ * Wire-schema shim: the projection value is plain JSON by construction, and
+ * pulling the real zod dependency in just to re-validate it would be waste.
+ */
+const outcomeSchema = {
+  parse: (value: unknown) => value as TurnOutcomeValue | null,
+} as ZodType<TurnOutcomeValue | null>
+
+declare module '@deepseek-ai/dsh-session-projection/types' {
+  interface SessionProjectionMap {
+    /** Outcome of the session's most recent agent turn; null before the first one ends. */
+    dshTurnOutcome: TurnOutcomeValue | null
+  }
+  interface SessionProjectionStateMap {
+    /** Host fold state for the turn-outcome key (same shape as the wire value). */
+    dshTurnOutcome: TurnOutcomeValue | null
+  }
+}
+
+/** Registration-ready unit type with the client-visible `wire` block narrowed in. */
+type TurnOutcomeProjectionUnit = Omit<
+  ProjectionDefinition<'dshTurnOutcome', TurnOutcomeValue | null>,
+  'wire'
+> & {
+  wire: NonNullable<ProjectionDefinition<'dshTurnOutcome', TurnOutcomeValue | null>['wire']>
+}
+
+/** The `dshTurnOutcome` projection unit: last-wins fold over `turn/end`. */
+export const turnOutcomeProjectionDefinition: TurnOutcomeProjectionUnit = {
+  key: TURN_OUTCOME_PROJECTION_KEY,
+  stateSchema: outcomeSchema,
+  init: () => null,
+  apply: (_state, event) => {
+    if (event.type !== 'turn/end') return _state
+    const { reason } = event.data
+    const value: TurnOutcomeValue = {
+      kind: reason.kind,
+      time: event.time,
+      turn: event.data.turn,
+      ...(reason.kind === 'error' && reason.error.message !== ''
+        ? { errorMessage: reason.error.message.slice(0, MAX_ERROR_CHARS) }
+        : {}),
+    }
+    return value
+  },
+  wire: {
+    viewSchema: outcomeSchema,
+    view: (state) => state,
+  },
+  stateVersion: 1,
+}
+
+/**
+ * Register the projection whenever the `sessionProjections` service is
+ * present. Headless assemblies without the registry stay unaffected.
+ * @param ctx - plugin context owning the registration effect.
+ */
+export function installTurnOutcomeProjection(ctx: Context): void {
+  ctx.inject(['sessionProjections'], (projectionCtx) => {
+    projectionCtx.sessionProjections.register(turnOutcomeProjectionDefinition)
+  })
+}

package/src/ui-tweaks/web.ts

@@ -0,0 +1,225 @@
+/**
+ * dsh-ui-tweaks — optional Web routes.
+ *
+ * The browser Settings panel reads and writes the `ui-tweaks` namespace through
+ * this same-origin route, because the Web settings RPC only exposes a fixed
+ * allowlist of namespaces (hardcoded in dsh-host-apiproxy since rc.6). The route
+ * proxies to the real `ctx.settings` service, so the settings document
+ * (settings.yaml) stays the single source of truth and hand edits keep working.
+ * @module dsh-ui-tweaks/web
+ */
+
+import { readFile } from 'node:fs/promises'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { Context } from '@deepseek-ai/cordis'
+// Type-only import activates the optional webServer Context declaration.
+import type {} from '@deepseek-ai/dsh-host-webserver'
+import { SettingsConflictError } from '@deepseek-ai/dsh-settings'
+import { UI_TWEAKS_SETTINGS_NAMESPACE } from './config.ts'
+
+/** Exact route used by the browser Settings page. */
+export const SETTINGS_ROUTE = '/_dsh/ui-tweaks/settings'
+/** Project-owned logo, served to the browser from the packaged assets folder. */
+export const LOGO_ROUTE = '/_dsh/ui-tweaks/assets/logo.svg'
+
+/** Public Settings snapshot; no secrets exist in this namespace. */
+export interface UITweaksSnapshot {
+  writable: boolean
+  value: unknown
+  revision: number
+}
+
+interface SetRequest {
+  action: 'set'
+  field: string
+  value: unknown
+  expectedRevision: number
+}
+
+interface UnsetRequest {
+  action: 'unset'
+  field: string
+  expectedRevision: number
+}
+
+type UITweaksRequest = SetRequest | UnsetRequest
+
+type JsonResponse<T> =
+  | { ok: true; value: T }
+  | { ok: false; error: { code: string; message: string } }
+
+/** Accept state-changing requests only from the DSH Web application's origin. */
+export function sameOriginPost(req: IncomingMessage): boolean {
+  const fetchSite = req.headers['sec-fetch-site']
+  if (fetchSite === 'cross-site') return false
+  const origin = req.headers.origin
+  if (origin === undefined) return fetchSite === 'same-origin' || fetchSite === 'same-site' || fetchSite === 'none'
+  const host = req.headers.host
+  if (host === undefined) return false
+  try {
+    const parsed = new URL(origin)
+    return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.host === host
+  } catch {
+    return false
+  }
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function json<T>(res: ServerResponse, status: number, body: JsonResponse<T>): void {
+  const bytes = Buffer.from(JSON.stringify(body))
+  res.setHeader('Content-Type', 'application/json; charset=utf-8')
+  res.setHeader('Content-Length', String(bytes.length))
+  res.setHeader('Cache-Control', 'no-store')
+  res.setHeader('X-Content-Type-Options', 'nosniff')
+  res.writeHead(status)
+  res.end(bytes)
+}
+
+export function requestError(res: ServerResponse, status: number, code: string, message: string): void {
+  json(res, status, { ok: false, error: { code, message } })
+}
+
+/** Serve the packaged project logo without exposing the rest of the filesystem. */
+async function serveLogo(_req: IncomingMessage, res: ServerResponse): Promise<void> {
+  try {
+    const body = await readFile(new URL('../assets/logo.svg', import.meta.url))
+    res.setHeader('Content-Type', 'image/svg+xml; charset=utf-8')
+    res.setHeader('Content-Length', String(body.length))
+    res.setHeader('Cache-Control', 'public, max-age=3600')
+    res.setHeader('X-Content-Type-Options', 'nosniff')
+    res.writeHead(200)
+    res.end(body)
+  } catch {
+    requestError(res, 404, 'logo-unavailable', 'Project logo is unavailable')
+  }
+}
+
+export async function readJson(req: IncomingMessage, maxBytes = 16 * 1024): Promise<unknown> {
+  const contentType = req.headers['content-type']?.split(';', 1)[0]?.trim().toLowerCase()
+  if (contentType !== 'application/json') throw new TypeError('Content-Type must be application/json')
+  const chunks: Buffer[] = []
+  let bytes = 0
+  for await (const chunk of req) {
+    const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+    bytes += part.length
+    if (bytes > maxBytes) throw new RangeError(`request body exceeds ${maxBytes} bytes`)
+    chunks.push(part)
+  }
+  if (chunks.length === 0) throw new TypeError('request body is empty')
+  return JSON.parse(Buffer.concat(chunks).toString('utf8')) as unknown
+}
+
+function parseRequest(value: unknown): UITweaksRequest {
+  if (!isRecord(value) || typeof value.action !== 'string') throw new TypeError('action is required')
+  if (typeof value.expectedRevision !== 'number' || !Number.isSafeInteger(value.expectedRevision) || (value.expectedRevision as number) < 0) {
+    throw new TypeError('expectedRevision must be a non-negative integer')
+  }
+  const field = value.field
+  if (typeof field !== 'string' || field.length === 0) throw new TypeError('field must be a non-empty string')
+  if (value.action === 'unset') {
+    return { action: 'unset', field, expectedRevision: value.expectedRevision as number }
+  }
+  if (value.action === 'set') {
+    return { action: 'set', field, value: value.value, expectedRevision: value.expectedRevision as number }
+  }
+  throw new TypeError(`unsupported action: ${value.action}`)
+}
+
+export function messageOf(error: unknown): string {
+  if (error instanceof Error) return error.message
+  return String(error)
+}
+
+/** Same-origin Settings read/write handler. */
+export class UITweaksWebBackend {
+  constructor(private readonly ctx: Context) {}
+
+  private descriptor() {
+    const row = this.ctx.settings.describe().find(candidate => candidate.ns === UI_TWEAKS_SETTINGS_NAMESPACE)
+    if (row === undefined) throw new Error('ui-tweaks settings namespace is not registered')
+    return row
+  }
+
+  private snapshot(): UITweaksSnapshot {
+    const descriptor = this.descriptor()
+    return {
+      writable: this.ctx.settings.writable,
+      value: descriptor.value,
+      revision: descriptor.revision,
+    }
+  }
+
+  /** Handle the exact Settings route. */
+  async handle(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    if (req.method === 'GET') {
+      try {
+        json(res, 200, { ok: true, value: this.snapshot() })
+      } catch (error) {
+        this.ctx.logger.warn('dsh-ui-tweaks Settings snapshot failed: %s', messageOf(error))
+        requestError(res, 503, 'settings-unavailable', 'UI Tweaks settings are unavailable')
+      }
+      return
+    }
+    if (req.method !== 'POST') {
+      res.setHeader('Allow', 'GET, POST')
+      requestError(res, 405, 'method-not-allowed', 'Use GET or POST')
+      return
+    }
+    if (!sameOriginPost(req)) {
+      requestError(res, 403, 'origin-rejected', 'The request must originate from this ChatCode CLI Web application')
+      return
+    }
+    let parsed: UITweaksRequest
+    try {
+      parsed = parseRequest(await readJson(req))
+    } catch (error) {
+      requestError(res, error instanceof RangeError ? 413 : 400, 'invalid-request', messageOf(error))
+      return
+    }
+    try {
+      if (parsed.action === 'set') {
+        await this.ctx.settings.update(UI_TWEAKS_SETTINGS_NAMESPACE, { [parsed.field]: parsed.value }, parsed.expectedRevision)
+      } else {
+        await this.ctx.settings.mutate(UI_TWEAKS_SETTINGS_NAMESPACE, [{ op: 'unset', path: [parsed.field] }], parsed.expectedRevision)
+      }
+      json(res, 200, { ok: true, value: this.snapshot() })
+    } catch (error) {
+      const conflict = error instanceof SettingsConflictError
+      requestError(
+        res,
+        conflict ? 409 : 400,
+        conflict ? 'settings-conflict' : 'settings-rejected',
+        messageOf(error),
+      )
+    }
+  }
+}
+
+/**
+ * Attach the Settings route whenever a webServer service is present.
+ * @param ctx - plugin context owning route effects.
+ * @param backend - Settings handler.
+ */
+export function installUITweaksWeb(ctx: Context, backend: UITweaksWebBackend): void {
+  ctx.inject(['webServer'], (webCtx) => {
+    webCtx.effect(() => {
+      const disposeSettings = webCtx.webServer.register({
+        kind: 'exact',
+        path: SETTINGS_ROUTE,
+        handler: (req, res) => backend.handle(req, res),
+      })
+      const disposeLogo = webCtx.webServer.register({
+        kind: 'exact',
+        path: LOGO_ROUTE,
+        handler: serveLogo,
+      })
+      return () => {
+        disposeLogo()
+        disposeSettings()
+      }
+    }, 'dsh-ui-tweaks: Web routes')
+  })
+}

package/src/wire.ts

@@ -0,0 +1,110 @@
+/**
+ * Wire helpers for the /sidebar JSON API: bounded body reading, response
+ * writing, and the shared error envelope. Every API method returns
+ * `{ok: true, value}` on success and `{ok: false, error: {code, message}}`
+ * (HTTP 4xx/5xx matching the code) on failure.
+ */
+import type { SidebarHttpRequest, SidebarHttpResponse } from './context-types.ts'
+
+/** Machine-readable error codes of the sidebar API. */
+export type SidebarErrorCode =
+  | 'bad-request'
+  | 'not-found'
+  | 'forbidden'
+  | 'method-error'
+  | 'too-large'
+  | 'fs-error'
+  | 'git-error'
+  | 'pty-error'
+  | 'pty-deps-missing'
+  | 'job-error'
+  | 'sidechat-error'
+  | 'subagents-unavailable'
+  | 'chatcode-unavailable'
+  | 'chatcode-unauthorized'
+  | 'chatcode-stats-unreachable'
+  | 'chatcode-stats-http'
+  | 'chatcode-stats-rejected'
+  | 'chatcode-update-fetch'
+  | 'chatcode-update-install'
+  | 'release-note-unreachable'
+  | 'release-note-http'
+  | 'release-note-rejected'
+  | 'settings-rejected'
+  | 'settings-conflict'
+  | 'internal'
+
+/** One API failure with its wire code and HTTP status. */
+export class SidebarError extends Error {
+  constructor(
+    readonly code: SidebarErrorCode,
+    message: string,
+    readonly status = 400,
+  ) {
+    super(message)
+  }
+}
+
+/** Body size bound of one JSON request (defense against unbounded reads). */
+const MAX_BODY_BYTES = 1 << 20
+
+/** Success envelope of one API method. */
+export interface SidebarOk<T> { ok: true; value: T }
+
+/** Failure envelope of one API method. */
+export interface SidebarErr { ok: false; error: { code: SidebarErrorCode; message: string } }
+
+/** Read and parse the JSON request body (bounded; malformed → bad-request). */
+export async function readJsonBody(req: SidebarHttpRequest): Promise<unknown> {
+  const chunks: Buffer[] = []
+  let total = 0
+  for await (const chunk of req) {
+    // The structural request yields string | Uint8Array; Buffer.from accepts
+    // both (and the real runtime chunks are node Buffers anyway).
+    const buffer = Buffer.from(chunk)
+    total += buffer.length
+    if (total > MAX_BODY_BYTES) {
+      throw new SidebarError('bad-request', 'request body too large')
+    }
+    chunks.push(buffer)
+  }
+  const text = Buffer.concat(chunks).toString('utf8')
+  if (text.trim() === '') return {}
+  try {
+    return JSON.parse(text) as unknown
+  } catch {
+    throw new SidebarError('bad-request', 'request body is not valid JSON')
+  }
+}
+
+/** Write a JSON response with the given status. */
+export function writeJson(res: SidebarHttpResponse, status: number, body: unknown): void {
+  const payload = JSON.stringify(body)
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' })
+  res.end(payload)
+}
+
+/** Write the success envelope. */
+export function writeOk(res: SidebarHttpResponse, value: unknown): void {
+  writeJson(res, 200, { ok: true, value })
+}
+
+/** Write the failure envelope for any thrown value (unknown → internal 500). */
+export function writeError(res: SidebarHttpResponse, error: unknown): void {
+  if (error instanceof SidebarError) {
+    writeJson(res, error.status, { ok: false, error: { code: error.code, message: error.message } })
+    return
+  }
+  const message = error instanceof Error ? error.message : String(error)
+  writeJson(res, 500, { ok: false, error: { code: 'internal', message } })
+}
+
+/** Narrow an unknown payload value to a string, else throw bad-request. */
+export function requireString(payload: unknown, key: string): string {
+  const record = payload as Record<string, unknown> | null
+  const value = record?.[key]
+  if (typeof value !== 'string' || value === '') {
+    throw new SidebarError('bad-request', `missing or invalid "${key}"`)
+  }
+  return value
+}

package/vendor/addon-fit.js

@@ -0,0 +1,2 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.FitAddon=t():e.FitAddon=t()}(globalThis,(()=>(()=>{"use strict";var e={};return(()=>{var t=e;Object.defineProperty(t,"__esModule",{value:!0}),t.FitAddon=void 0,t.FitAddon=class{activate(e){this._terminal=e}dispose(){}fit(){const e=this.proposeDimensions();if(!e||!this._terminal||isNaN(e.cols)||isNaN(e.rows))return;const t=this._terminal._core;this._terminal.rows===e.rows&&this._terminal.cols===e.cols||(t._renderService.clear(),this._terminal.resize(e.cols,e.rows))}proposeDimensions(){if(!this._terminal)return;if(!this._terminal.element||!this._terminal.element.parentElement)return;const e=this._terminal._core._renderService.dimensions;if(0===e.css.cell.width||0===e.css.cell.height)return;const t=0===this._terminal.options.scrollback?0:this._terminal.options.overviewRuler?.width||14,r=window.getComputedStyle(this._terminal.element.parentElement),i=parseInt(r.getPropertyValue("height")),o=Math.max(0,parseInt(r.getPropertyValue("width"))),s=window.getComputedStyle(this._terminal.element),n=i-(parseInt(s.getPropertyValue("padding-top"))+parseInt(s.getPropertyValue("padding-bottom"))),l=o-(parseInt(s.getPropertyValue("padding-right"))+parseInt(s.getPropertyValue("padding-left")))-t;return{cols:Math.max(2,Math.floor(l/e.css.cell.width)),rows:Math.max(1,Math.floor(n/e.css.cell.height))}}}})(),e})()));
+//# sourceMappingURL=addon-fit.js.map

package/vendor/xterm.css

@@ -0,0 +1,218 @@
+/**
+ * Copyright (c) 2014 The xterm.js authors. All rights reserved.
+ * Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
+ * https://github.com/chjj/term.js
+ * @license MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Originally forked from (with the author's permission):
+ *   Fabrice Bellard's javascript vt100 for jslinux:
+ *   http://bellard.org/jslinux/
+ *   Copyright (c) 2011 Fabrice Bellard
+ *   The original design remains. The terminal itself
+ *   has been extended to include xterm CSI codes, among
+ *   other features.
+ */
+
+/**
+ *  Default styles for xterm.js
+ */
+
+.xterm {
+    cursor: text;
+    position: relative;
+    user-select: none;
+    -ms-user-select: none;
+    -webkit-user-select: none;
+}
+
+.xterm.focus,
+.xterm:focus {
+    outline: none;
+}
+
+.xterm .xterm-helpers {
+    position: absolute;
+    top: 0;
+    /**
+     * The z-index of the helpers must be higher than the canvases in order for
+     * IMEs to appear on top.
+     */
+    z-index: 5;
+}
+
+.xterm .xterm-helper-textarea {
+    padding: 0;
+    border: 0;
+    margin: 0;
+    /* Move textarea out of the screen to the far left, so that the cursor is not visible */
+    position: absolute;
+    opacity: 0;
+    left: -9999em;
+    top: 0;
+    width: 0;
+    height: 0;
+    z-index: -5;
+    /** Prevent wrapping so the IME appears against the textarea at the correct position */
+    white-space: nowrap;
+    overflow: hidden;
+    resize: none;
+}
+
+.xterm .composition-view {
+    /* TODO: Composition position got messed up somewhere */
+    background: #000;
+    color: #FFF;
+    display: none;
+    position: absolute;
+    white-space: nowrap;
+    z-index: 1;
+}
+
+.xterm .composition-view.active {
+    display: block;
+}
+
+.xterm .xterm-viewport {
+    /* On OS X this is required in order for the scroll bar to appear fully opaque */
+    background-color: #000;
+    overflow-y: scroll;
+    cursor: default;
+    position: absolute;
+    right: 0;
+    left: 0;
+    top: 0;
+    bottom: 0;
+}
+
+.xterm .xterm-screen {
+    position: relative;
+}
+
+.xterm .xterm-screen canvas {
+    position: absolute;
+    left: 0;
+    top: 0;
+}
+
+.xterm .xterm-scroll-area {
+    visibility: hidden;
+}
+
+.xterm-char-measure-element {
+    display: inline-block;
+    visibility: hidden;
+    position: absolute;
+    top: 0;
+    left: -9999em;
+    line-height: normal;
+}
+
+.xterm.enable-mouse-events {
+    /* When mouse events are enabled (eg. tmux), revert to the standard pointer cursor */
+    cursor: default;
+}
+
+.xterm.xterm-cursor-pointer,
+.xterm .xterm-cursor-pointer {
+    cursor: pointer;
+}
+
+.xterm.column-select.focus {
+    /* Column selection mode */
+    cursor: crosshair;
+}
+
+.xterm .xterm-accessibility:not(.debug),
+.xterm .xterm-message {
+    position: absolute;
+    left: 0;
+    top: 0;
+    bottom: 0;
+    right: 0;
+    z-index: 10;
+    color: transparent;
+    pointer-events: none;
+}
+
+.xterm .xterm-accessibility-tree:not(.debug) *::selection {
+  color: transparent;
+}
+
+.xterm .xterm-accessibility-tree {
+  user-select: text;
+  white-space: pre;
+}
+
+.xterm .live-region {
+    position: absolute;
+    left: -9999px;
+    width: 1px;
+    height: 1px;
+    overflow: hidden;
+}
+
+.xterm-dim {
+    /* Dim should not apply to background, so the opacity of the foreground color is applied
+     * explicitly in the generated class and reset to 1 here */
+    opacity: 1 !important;
+}
+
+.xterm-underline-1 { text-decoration: underline; }
+.xterm-underline-2 { text-decoration: double underline; }
+.xterm-underline-3 { text-decoration: wavy underline; }
+.xterm-underline-4 { text-decoration: dotted underline; }
+.xterm-underline-5 { text-decoration: dashed underline; }
+
+.xterm-overline {
+    text-decoration: overline;
+}
+
+.xterm-overline.xterm-underline-1 { text-decoration: overline underline; }
+.xterm-overline.xterm-underline-2 { text-decoration: overline double underline; }
+.xterm-overline.xterm-underline-3 { text-decoration: overline wavy underline; }
+.xterm-overline.xterm-underline-4 { text-decoration: overline dotted underline; }
+.xterm-overline.xterm-underline-5 { text-decoration: overline dashed underline; }
+
+.xterm-strikethrough {
+    text-decoration: line-through;
+}
+
+.xterm-screen .xterm-decoration-container .xterm-decoration {
+	z-index: 6;
+	position: absolute;
+}
+
+.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer {
+	z-index: 7;
+}
+
+.xterm-decoration-overview-ruler {
+    z-index: 8;
+    position: absolute;
+    top: 0;
+    right: 0;
+    pointer-events: none;
+}
+
+.xterm-decoration-top {
+    z-index: 2;
+    position: relative;
+}