rterm-backend 3.0.9 → 3.1.1

package/package.json

@@ -1,71 +1,14 @@
 {
   "name": "rterm-backend",
-  "version": "3.0.9",
-  "description": "Headless AI-native backend for RTerm / neuralOS — v3.0.9: web-intel plugin (local-first web intelligence via wigolo; lean-by-default, synthesis by RTerm agent).",
+  "version": "3.1.1",
+  "description": "Headless AI-native backend for RTerm / neuralOS — v3.1.1: serial transport fix (SerialPort class resolution + v9/v10+ call-signature tolerance) and serialport declared so SSH/serial/local transports install automatically.",
   "main": "bin/gybackend.cjs",
-  "bin": {
-    "gybackend": "bin/gybackend.cjs",
-    "rterm-backend": "bin/gybackend.cjs"
-  },
-  "scripts": {
-    "start": "node bin/gybackend.cjs"
-  },
-  "dependencies": {
-    "@nats-io/transport-node": "^3.4.0",
-    "better-sqlite3": "^12.11.1",
-    "cpu-features": "^0.0.10",
-    "node-pty": "^1.2.0-beta.3",
-    "ssh2": "^1.17.0",
-    "tree-sitter-bash": "^0.25.1",
-    "web-tree-sitter": "^0.26.3"
-  },
+  "bin": { "gybackend": "bin/gybackend.cjs" },
+  "license": "MIT",
+  "engines": { "node": ">=18" },
   "optionalDependencies": {
-    "serialport": "^13.0.0"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "os": [
-    "darwin",
-    "linux",
-    "win32"
-  ],
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/DrOlu/RTerm.git"
-  },
-  "keywords": [
-    "rterm-backend",
-    "neuralos",
-    "rterm",
-    "terminal",
-    "ssh",
-    "winrm",
-    "serial",
-    "ai-agent",
-    "llm",
-    "devops",
-    "fleet",
-    "automation",
-    "headless",
-    "backend",
-    "daemon",
-    "websocket",
-    "rpc",
-    "sre",
-    "observability",
-    "prometheus",
-    "opentelemetry",
-    "secrets",
-    "on-call",
-    "gitops",
-    "cloud-inventory",
-    "apm",
-    "dem",
-    "etw",
-    "agentspan",
-    "conductor",
-    "monitoring"
-  ]
+    "serialport": "^12.0.0",
+    "ssh2": "^1.17.0",
+    "node-pty": "1.2.0-beta.3"
+  }
 }

package/plugins/sample-k8s-slo/index.ts

@@ -0,0 +1,58 @@
+/**
+ * Sample plugin — Kubernetes SLO tracker.
+ *
+ * Demonstrates the RTerm plugin system: it registers an agent tool (evaluate a
+ * service's SLO from pod health), an event-driven trigger (pod CrashLoopBackOff),
+ * and a dashboard panel (the k8s SLO board). RTerm discovers this folder, loads
+ * it, calls register(ctx) with RTerm's services, and the capabilities appear
+ * automatically — the agent can then call k8s_slo_evaluate, and the trigger fires
+ * when a pod crashloops.
+ */
+import type { PluginContext } from '../../packages/backend/src/services/plugin/pluginRegistry'
+
+export function register(ctx: PluginContext): void {
+  ctx.log('[sample-k8s-slo] registering')
+
+  // Agent tool: evaluate a service's SLO from its pods.
+  ctx.registerTool({
+    name: 'k8s_slo_evaluate',
+    description: 'Evaluate a Kubernetes service SLO (SLI + error budget + burn rate) from its pod health.',
+    handler: async (args: Record<string, unknown>) => {
+      const service = String(args.service ?? 'default')
+      // In a real plugin this would run `kubectl get pods` via ctx.exec and compute.
+      // Here we return a structured stub so the agent can reason about it.
+      return {
+        service,
+        sli: 0.9992,
+        errorBudgetRemaining: 0.62,
+        burnRate: 0.38,
+        fastBurning: false,
+        podsReady: '12/13',
+        note: 'computed by the sample-k8s-slo plugin',
+      }
+    },
+  })
+
+  // Agent tool: list pods with high restart counts.
+  ctx.registerTool({
+    name: 'k8s_pod_restarts',
+    description: 'List Kubernetes pods with a restart count above a threshold.',
+    handler: async (args: Record<string, unknown>) => {
+      const min = Number(args.minRestarts ?? 5)
+      return { threshold: min, pods: [{ name: 'cache-5b7a2', restarts: 12, ready: false }], note: 'computed by the sample-k8s-slo plugin' }
+    },
+  })
+
+  // Trigger: fire a critical alert when a pod crashloops.
+  ctx.registerTrigger({
+    name: 'k8s-pod-crashloop',
+    kind: 'pattern',
+    match: 'CrashLoopBackOff',
+    action: 'critical-alert',
+  })
+
+  // Dashboard panel: the k8s SLO board.
+  ctx.registerPanel('k8s-slo-board', async () => {
+    return '<h3>Kubernetes SLO Board</h3><p>Rendered by the sample-k8s-slo plugin.</p>'
+  })
+}

package/plugins/sample-k8s-slo/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "sample-k8s-slo",
+  "version": "1.0.0",
+  "description": "Sample plugin: track SLOs for Kubernetes services and alert on pod crashes",
+  "author": "RTerm",
+  "entry": "index.ts",
+  "tools": ["k8s_slo_evaluate", "k8s_pod_restarts"],
+  "triggers": [{ "name": "k8s-pod-crashloop", "kind": "pattern", "match": "CrashLoopBackOff" }],
+  "panels": ["k8s-slo-board"],
+  "permissions": ["exec_command", "read_ledger"]
+}

package/plugins/web-intel/web-intel.extreme.spec.ts

@@ -0,0 +1,263 @@
+/**
+ * web-intel.extreme.spec.ts — exhaustive offline tests for the web-intel plugin:
+ * the dependency-free wigolo REST client (URL building, auth header, error
+ * mapping, every endpoint), the sidecar lifecycle (lean-by-default spawn plan,
+ * start/stop/status), and the plugin glue (config resolution, tool wiring,
+ * unreachable-daemon resilience, result normalization, trigger match). No
+ * network — fetch is mocked; spawn is injected/mocked.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { WigoloClient, WigoloApiError, buildHeaders, joinUrl, DEFAULT_BASE_URL } from './wigoloClient.mjs'
+import { WigoloSidecar, buildServePlan, buildInitPlan } from './sidecar.mjs'
+import {
+  register,
+  resolveConfig,
+  buildClient,
+  toResultRows,
+  toPageSummary,
+  toResearchBrief,
+  toWatchRows,
+  isPageChangedEvent,
+} from './index.mjs'
+
+// ─── mock fetch ─────────────────────────────────────────────────────────────
+function mockFetch(respond) {
+  const calls = []
+  const fn = async (url, init) => {
+    calls.push({ url, init })
+    const r = typeof respond === 'function' ? respond(url, init, calls.length) : respond
+    return { ok: r.ok !== false && (r.status ?? 200) < 400, status: r.status ?? 200, text: async () => r.text ?? (r.json !== undefined ? JSON.stringify(r.json) : '') }
+  }
+  fn.calls = calls
+  return fn
+}
+
+// ─── wigoloClient ───────────────────────────────────────────────────────────
+
+test('joinUrl joins base + path with a single slash', () => {
+  assert.equal(joinUrl('http://x:3333/', '/health'), 'http://x:3333/health')
+  assert.equal(joinUrl('http://x:3333', 'health'), 'http://x:3333/health')
+  assert.equal(joinUrl('', '/v1/search'), `${DEFAULT_BASE_URL}/v1/search`)
+})
+
+test('buildHeaders adds bearer token only when set', () => {
+  assert.equal(buildHeaders().authorization, undefined)
+  assert.equal(buildHeaders('tok').authorization, 'Bearer tok')
+})
+
+test('client.health() GETs /health without auth and maps ok/error', async () => {
+  const up = mockFetch({ json: { status: 'ok', searxng: 'not_configured' } })
+  const c = new WigoloClient({ fetchImpl: up })
+  const h = await c.health()
+  assert.equal(h.ok, true)
+  assert.equal(up.calls[0].url, `${DEFAULT_BASE_URL}/health`)
+
+  const down = mockFetch(() => { throw new Error('ECONNREFUSED') })
+  const h2 = await new WigoloClient({ fetchImpl: down }).health()
+  assert.equal(h2.ok, false)
+  assert.match(h2.error, /ECONNREFUSED/)
+})
+
+test('client.search() POSTs query (+ array) to /v1/search with token header', async () => {
+  const f = mockFetch({ json: { results: [] } })
+  const c = new WigoloClient({ token: 'tok', fetchImpl: f })
+  await c.search(['a', 'b'], { time_range: 'week', max_results: 5 })
+  assert.equal(f.calls[0].url, `${DEFAULT_BASE_URL}/v1/search`)
+  assert.equal(f.calls[0].init.method, 'POST')
+  assert.equal(f.calls[0].init.headers.authorization, 'Bearer tok')
+  const body = JSON.parse(f.calls[0].init.body)
+  assert.deepEqual(body.query, ['a', 'b'])
+  assert.equal(body.time_range, 'week')
+  assert.equal(body.max_results, 5)
+})
+
+test('client maps non-2xx to WigoloApiError with status', async () => {
+  const f = mockFetch({ status: 500, text: 'boom' })
+  const c = new WigoloClient({ fetchImpl: f })
+  await assert.rejects(() => c.fetch('https://x'), (e) => {
+    assert.ok(e instanceof WigoloApiError)
+    assert.equal(e.status, 500)
+    return true
+  })
+})
+
+test('client.watch() sends action + url for create/list/remove', async () => {
+  const f = mockFetch({ json: { id: 'w1' } })
+  const c = new WigoloClient({ fetchImpl: f })
+  await c.watch('create', { url: 'https://x', interval: '1h' })
+  assert.equal(JSON.parse(f.calls[0].init.body).action, 'create')
+  await c.watch('list')
+  assert.equal(JSON.parse(f.calls[1].init.body).action, 'list')
+  await c.watch('remove', { id: 'w1' })
+  assert.equal(JSON.parse(f.calls[2].init.body).action, 'remove')
+})
+
+// ─── sidecar ────────────────────────────────────────────────────────────────
+
+test('buildServePlan is lean by default (WIGOLO_NO_WARMUP=1, no token)', () => {
+  const p = buildServePlan({})
+  assert.equal(p.command, 'npx')
+  assert.deepEqual(p.args.slice(0, 3), ['-y', 'wigolo', 'serve'])
+  assert.equal(p.env.WIGOLO_NO_WARMUP, '1')
+  assert.equal(p.env.WIGOLO_API_TOKEN, undefined)
+})
+
+test('buildServePlan honors port/host/token and warmup=true omits the no-warmup flag', () => {
+  const p = buildServePlan({ port: 3477, host: '0.0.0.0', token: 't', warmup: true })
+  assert.ok(p.args.includes('3477'))
+  assert.equal(p.env.WIGOLO_NO_WARMUP, undefined)
+  assert.equal(p.env.WIGOLO_API_TOKEN, 't')
+})
+
+test('sidecar.start() spawns detached + unref and is idempotent', async () => {
+  const spawned = []
+  const spawnImpl = (cmd, args, opts) => { spawned.push({ cmd, args, opts }); return { unref() {}, kill() {} } }
+  const sc = new WigoloSidecar({ spawnImpl, log: () => {} })
+  await sc.start()
+  await sc.start() // idempotent — no second spawn
+  assert.equal(spawned.length, 1)
+  assert.equal(spawned[0].opts.detached, true)
+  assert.equal(sc.isRunning(), true)
+  assert.equal(sc.status().warmup, 'lean (no warmup)')
+})
+
+test('sidecar.stop() kills the process', async () => {
+  let killed = false
+  const spawnImpl = () => ({ unref() {}, kill() { killed = true } })
+  const sc = new WigoloSidecar({ spawnImpl, log: () => {} })
+  await sc.start()
+  await sc.stop()
+  assert.equal(killed, true)
+  assert.equal(sc.isRunning(), false)
+})
+
+// ─── plugin glue ────────────────────────────────────────────────────────────
+
+function makeCtx(fetchImpl, settings = {}, spawnProcess) {
+  const tools = new Map()
+  const triggers = []
+  const panels = []
+  const logs = []
+  const ctx = {
+    settings: { webIntel: settings },
+    fetchImpl,
+    registerTool: (t) => tools.set(t.name, t),
+    registerTrigger: (t) => triggers.push(t),
+    registerPanel: (p) => panels.push(p),
+    log: (l) => logs.push(l),
+    ...(spawnProcess ? { spawnProcess } : {}),
+  }
+  return { tools, triggers, panels, logs, ctx }
+}
+
+test('resolveConfig reads the webIntel block with lean defaults', () => {
+  const c = resolveConfig({ settings: { webIntel: { restUrl: ' http://x:3477/ ', warmupOnInit: true, autoStart: false } } })
+  assert.equal(c.restUrl, 'http://x:3477', 'restUrl trimmed of whitespace + trailing slash')
+  assert.equal(c.warmupOnInit, true)
+  assert.equal(c.autoStart, false)
+  const d = resolveConfig({ settings: {} })
+  assert.equal(d.enabled, true)
+  assert.equal(d.autoStart, true)
+  assert.equal(d.warmupOnInit, false)
+})
+
+test('register wires 9 tools, 1 trigger, 1 panel', () => {
+  const { tools, triggers, panels, ctx } = makeCtx(mockFetch({ json: {} }))
+  register(ctx)
+  assert.equal(tools.size, 9)
+  for (const n of ['webintel_health', 'web_search', 'web_fetch', 'web_crawl', 'web_research', 'web_find_similar', 'web_watch_add', 'web_watch_list', 'web_watch_remove']) assert.ok(tools.has(n), `missing ${n}`)
+  assert.equal(triggers.length, 1)
+  assert.equal(panels.length, 1)
+})
+
+test('web_search returns normalized ranked results', async () => {
+  const f = mockFetch((url) => url.endsWith('/health')
+    ? { json: { status: 'ok' } }
+    : { json: { results: [{ title: 'A', url: 'https://a', excerpt: 'x'.repeat(300), citation_id: 'src-1', evidence_score: { final: 0.9 } }], freshness_signal: { published: '2026-07-01' } } })
+  const { tools, ctx } = makeCtx(f)
+  register(ctx)
+  const r = await tools.get('web_search').handler({ query: 'cisco bgp error' })
+  assert.equal(r.results.length, 1)
+  assert.equal(r.results[0].citation, 'src-1')
+  assert.equal(r.results[0].score, 0.9)
+  assert.ok(r.results[0].excerpt.length <= 240)
+  assert.equal(r.freshness.published, '2026-07-01')
+})
+
+test('web_research returns the evidence brief (synthesis left to RTerm agent)', async () => {
+  const f = mockFetch((url) => url.endsWith('/health')
+    ? { json: { status: 'ok' } }
+    : { json: { question: 'q', evidence: [{ title: 'S', url: 'https://s', snippet: 'ev' }], citations: [{ id: 'src-1', url: 'https://s' }] } })
+  const { tools, ctx } = makeCtx(f)
+  register(ctx)
+  const r = await tools.get('web_research').handler({ question: 'is rijndael128-cbc safe' })
+  assert.equal(r.evidence.length, 1)
+  assert.equal(r.citations.length, 1)
+  assert.match(r.note, /RTerm agent/)
+})
+
+test('web_fetch surfaces a blocked page honestly', async () => {
+  const f = mockFetch((url) => url.endsWith('/health')
+    ? { json: { status: 'ok' } }
+    : { json: { url: 'https://x', blocked_by_challenge: true, markdown: '' } })
+  const { tools, ctx } = makeCtx(f)
+  register(ctx)
+  const r = await tools.get('web_fetch').handler({ url: 'https://x' })
+  assert.equal(r.blocked, true)
+})
+
+test('every web_* tool returns error+hint when daemon is down and no spawn (no throw)', async () => {
+  const down = mockFetch(() => { throw new Error('ECONNREFUSED') })
+  const { tools, ctx } = makeCtx(down, { autoStart: true }) // no spawnProcess → can't start
+  register(ctx)
+  const r = await tools.get('web_search').handler({ query: 'x' })
+  assert.ok(r.error)
+  assert.match(r.hint, /wigolo daemon/)
+})
+
+test('web_search auto-starts the daemon via spawnProcess then serves', async () => {
+  let healthy = false
+  const spawned = []
+  const f = mockFetch((url) => url.endsWith('/health')
+    ? (healthy ? { json: { status: 'ok' } } : (() => { throw new Error('down') })())
+    : { json: { results: [] } })
+  const spawnProcess = (cmd, args, opts) => { spawned.push(true); healthy = true; return { unref() {}, kill() {} } }
+  const { tools, ctx } = makeCtx(f, { autoStart: true }, spawnProcess)
+  register(ctx)
+  const r = await tools.get('web_search').handler({ query: 'x' })
+  assert.equal(spawned.length, 1)
+  assert.ok(Array.isArray(r.results))
+})
+
+test('webintel_page_changed trigger matches only webintel change events', () => {
+  const { triggers, ctx } = makeCtx(mockFetch({ json: {} }))
+  register(ctx)
+  const m = triggers[0].match
+  assert.equal(m({ source: 'webintel', changed: true }), true)
+  assert.equal(m({ source: 'webintel', kind: 'page_changed' }), true)
+  assert.equal(m({ source: 'agentspan', changed: true }), false)
+  assert.equal(m({ source: 'webintel', changed: false }), false)
+})
+
+// ─── normalization helpers ─────────────────────────────────────────────────
+
+test('toResultRows normalizes + truncates excerpts', () => {
+  const rows = toResultRows({ results: [{ url: 'https://a', description: 'y'.repeat(400) }] })
+  assert.equal(rows.length, 1)
+  assert.ok(rows[0].excerpt.length <= 240)
+  assert.equal(toResultRows({}).length, 0)
+})
+
+test('toResearchBrief handles empty payload', () => {
+  assert.deepEqual(toResearchBrief(null).evidence, [])
+  assert.equal(toResearchBrief({ evidence: [] }).evidence.length, 0)
+})
+
+test('toWatchRows normalizes watch entries', () => {
+  const rows = toWatchRows({ watches: [{ id: 'w1', url: 'https://x', changed: true, last_checked: '2026-07-28' }] })
+  assert.equal(rows.length, 1)
+  assert.equal(rows[0].changed, true)
+})
+
+console.log('web-intel: all cases passed')

package/LICENSE.md

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          in such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 Hyperspace Technologies
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/README.md

@@ -1,31 +0,0 @@
-# gybackend
-
-Backend runtime bootstrap workspace for GyShell (internal/development entry).
-
-## Run
-
-```bash
-npm --workspace @gyshell/gybackend run build
-npm --workspace @gyshell/gybackend run start
-```
-
-This workspace is mainly for repository development and runtime debugging. End users should use the desktop app. `gyll` / CLI TUI is deprecated and unsupported.
-
-## Environment Variables
-
-- `GYBACKEND_WS_HOST` (default `0.0.0.0`)
-- `GYBACKEND_WS_PORT` (default `17888`)
-- `GYBACKEND_DATA_DIR` (default `./.gybackend-data` under current working directory)
-- `GYBACKEND_BOOTSTRAP_LOCAL_TERMINAL` (default `true`)
-- `GYBACKEND_TERMINAL_ID` (default `local-main`)
-- `GYBACKEND_TERMINAL_TITLE` (default `Local`)
-- `GYBACKEND_TERMINAL_CWD` (optional)
-- `GYBACKEND_TERMINAL_SHELL` (optional)
-- `GYBACKEND_MODEL` (optional bootstrap model name)
-- `GYBACKEND_API_KEY` (optional bootstrap model API key)
-- `GYBACKEND_BASE_URL` (optional bootstrap model base URL)
-
-## Notes
-
-- gybackend delegates shared backend behavior to `packages/backend`.
-- MCP runtime is active through the shared backend core.