dsh-side-chat-plus 0.3.1

package/src/settings-shared.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared side-chat preference vocabulary (types + constants), consumed by
+ * BOTH halves: the host registers the schemastery schema over these values
+ * (index.ts) and the client reads/writes them through the plugin's own
+ * fenced /sidechat settings routes. Kept free of schemastery so the browser
+ * bundle never pulls the schema runtime in.
+ */
+
+/** The user-settings namespace holding the side-chat preferences. */
+export const SUBCHAT_PREFS_NS = 'dsh-side-chat'
+
+/** How a brought-back reply lands in the main conversation. */
+export type BringMode = 'draft' | 'context'
+
+/** User-facing side-chat preferences. */
+export interface SubchatPrefs {
+  /** Whether the "look up workspace / parent when needed" switch defaults on. */
+  lookupDefault: boolean
+  /** Whether selecting text sends it immediately (true) or stages it as an attachment (false). */
+  sendImmediately: boolean
+  /** Extra prompt appended when the selection is sent immediately (empty = none). */
+  defaultPrompt: string
+  /** How brought-back content lands: into the composer draft, or as a collapsed context row. */
+  bringMode: BringMode
+}
+
+/** Fallback prefs used whenever the settings document is unreachable or malformed. */
+export const SUBCHAT_PREFS_DEFAULTS: SubchatPrefs = {
+  lookupDefault: false,
+  sendImmediately: true,
+  defaultPrompt: '',
+  bringMode: 'draft',
+}

package/src/trust-fence.ts

@@ -0,0 +1,70 @@
+/**
+ * Browser-trust fence for the /sidechat routes, behaviorally identical to the
+ * /api gateway's fence (loopback or configured trusted authority; cross-site
+ * browser markers refuse). Self-contained copy, since the DSH connection
+ * package does not export these helpers.
+ */
+import type { IncomingHttpHeaders } from 'node:http'
+
+interface ApiTrustRequest {
+  headers: IncomingHttpHeaders
+}
+
+function header(headers: IncomingHttpHeaders, name: string): string | undefined {
+  const value = headers[name]
+  return typeof value === 'string' ? value : undefined
+}
+
+function parseAuthority(authority: string): URL | undefined {
+  try {
+    return new URL(`http://${authority}`)
+  } catch {
+    return undefined
+  }
+}
+
+/** Whether a normalized URL hostname names the local loopback authority. */
+export function isLoopbackHostname(hostname: string): boolean {
+  if (hostname === 'localhost' || hostname === '[::1]') return true
+  const parts = hostname.split('.')
+  return parts.length === 4
+    && parts[0] === '127'
+    && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255)
+}
+
+function canonicalAuthority(entry: string, entryUrl: URL): string {
+  const port = entryUrl.port !== '' ? entryUrl.port : new URL(`https://${entry}`).port
+  return port === '' ? entryUrl.hostname : `${entryUrl.hostname}:${port}`
+}
+
+function isTrustedAuthority(hostUrl: URL, trustedHosts: readonly string[]): boolean {
+  return trustedHosts.some((entry) => {
+    const entryUrl = parseAuthority(entry)
+    if (entryUrl === undefined) return false
+    return canonicalAuthority(entry, entryUrl) === entryUrl.hostname
+      ? entryUrl.hostname === hostUrl.hostname
+      : entryUrl.host === hostUrl.host
+  })
+}
+
+/**
+ * Decide whether one sidechat request may reach the plugin routes.
+ * @param request - node HTTP request facts (headers).
+ * @param trustedHosts - non-loopback authorities this deployment serves.
+ * @returns true when the Host is ours (loopback or trusted) and browser markers are same-origin.
+ */
+export function isTrustedApiRequest(request: ApiTrustRequest, trustedHosts: readonly string[]): boolean {
+  const host = header(request.headers, 'host')
+  if (host === undefined) return false
+  const hostUrl = parseAuthority(host)
+  if (hostUrl === undefined) return false
+  if (!isLoopbackHostname(hostUrl.hostname) && !isTrustedAuthority(hostUrl, trustedHosts)) return false
+  if (header(request.headers, 'sec-fetch-site') === 'cross-site') return false
+  const origin = header(request.headers, 'origin')
+  if (origin === undefined) return true
+  try {
+    return new URL(origin).host === hostUrl.host
+  } catch {
+    return false
+  }
+}

package/src/wire.ts

@@ -0,0 +1,81 @@
+/**
+ * Wire helpers for the /sidechat JSON API: bounded body reading, response
+ * writing, and the shared error envelope. Mirrors the /sidebar wire helpers
+ * (loopback + trusted-host fence), kept self-contained so the plugin never
+ * depends on the DSH gateway internals.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http'
+
+/** One API failure with its wire code and HTTP status. */
+export class SidechatError extends Error {
+  constructor(
+    readonly code: string,
+    message: string,
+    readonly status = 400,
+  ) {
+    super(message)
+  }
+}
+
+/** Body size bound of one JSON request. */
+const MAX_BODY_BYTES = 1 << 20
+
+/** Read and parse the JSON request body (bounded; malformed → bad-request). */
+export async function readJsonBody(req: IncomingMessage): Promise<unknown> {
+  const chunks: Buffer[] = []
+  let total = 0
+  for await (const chunk of req) {
+    const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk
+    total += buffer.length
+    if (total > MAX_BODY_BYTES) {
+      throw new SidechatError('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 SidechatError('bad-request', 'request body is not valid JSON')
+  }
+}
+
+/** Write a JSON response with the given status. */
+export function writeJson(res: ServerResponse, 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: ServerResponse, value: unknown): void {
+  writeJson(res, 200, { ok: true, value })
+}
+
+/** Write the failure envelope for any thrown value (unknown → internal 500). */
+export function writeError(res: ServerResponse, error: unknown): void {
+  if (error instanceof SidechatError) {
+    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 SidechatError('bad-request', `missing or invalid "${key}"`)
+  }
+  return value
+}
+
+/** Narrow an unknown payload value to a boolean (default false). */
+export function optionalBoolean(payload: unknown, key: string): boolean {
+  const record = payload as Record<string, unknown> | null
+  const value = record?.[key]
+  return value === true
+}