ghost-dragon 4.2.1

package/test/security.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Security-critical pure-logic tests (the adversarial layer). Run against the
+ * built output so there's no train/serve skew: `npm run build && vitest run`.
+ *
+ * Covers the guards that stand between an LLM (or a poisoned config) and the
+ * operator's machine: URL/SSRF guard, credential header-injection, secret
+ * redaction, and working-dir confinement.
+ */
+import { describe, it, expect } from 'vitest'
+import { isBrowsableHttpUrl, sanitizeApiBase, validCred, DEFAULT_API } from '../dist/auth.js'
+import { redact } from '../dist/agent/trace.js'
+import { guardPath } from '../dist/agent/tools.js'
+import { resolveProvider } from '../dist/brain/index.js'
+
+describe('isBrowsableHttpUrl — restricted-port / SSRF guard', () => {
+  it('accepts https on normal hosts', () => {
+    expect(isBrowsableHttpUrl('https://account.ghosts.lk')).toBe(true)
+    expect(isBrowsableHttpUrl('https://account.ghosts.lk/cli?code=X')).toBe(true)
+  })
+  it('accepts http only on loopback', () => {
+    expect(isBrowsableHttpUrl('http://localhost:8799')).toBe(true)
+    expect(isBrowsableHttpUrl('http://127.0.0.1:8787')).toBe(true)
+    expect(isBrowsableHttpUrl('http://evil.example.com')).toBe(false) // remote must be https
+  })
+  it('rejects restricted ports (the "address is restricted" bug)', () => {
+    for (const p of [1, 22, 25, 6000, 6667]) {
+      expect(isBrowsableHttpUrl(`http://127.0.0.1:${p}`)).toBe(false)
+      expect(isBrowsableHttpUrl(`https://x.test:${p}`)).toBe(false)
+    }
+  })
+  it('rejects non-http(s) + junk', () => {
+    expect(isBrowsableHttpUrl('ftp://x.test')).toBe(false)
+    expect(isBrowsableHttpUrl('file:///etc/passwd')).toBe(false)
+    expect(isBrowsableHttpUrl('not a url')).toBe(false)
+    expect(isBrowsableHttpUrl('javascript:alert(1)')).toBe(false)
+  })
+})
+
+describe('sanitizeApiBase — self-heal', () => {
+  it('keeps a valid base, strips trailing slash', () => {
+    expect(sanitizeApiBase('https://account.ghosts.lk/')).toBe('https://account.ghosts.lk')
+  })
+  it('falls back to default on junk / restricted port', () => {
+    expect(sanitizeApiBase('http://127.0.0.1:1')).toBe(DEFAULT_API)
+    expect(sanitizeApiBase('ftp://x')).toBe(DEFAULT_API)
+    expect(sanitizeApiBase(undefined)).toBe(DEFAULT_API)
+    expect(sanitizeApiBase('')).toBe(DEFAULT_API)
+  })
+})
+
+describe('validCred — header-injection guard', () => {
+  it('accepts a clean token/session', () => {
+    expect(validCred('dgn_C2sMFq5KXYPBrku7kfL3')).toBeTruthy()
+    expect(validCred('abc123-_.')).toBeTruthy()
+  })
+  it('rejects CRLF / control chars / spaces (no header smuggling)', () => {
+    expect(validCred('tok\r\nX-Evil: 1')).toBeUndefined()
+    expect(validCred('tok\nfoo')).toBeUndefined()
+    expect(validCred('tok with space')).toBeUndefined()
+    expect(validCred('')).toBeUndefined()
+    expect(validCred(undefined)).toBeUndefined()
+  })
+})
+
+describe('redact — secret stripping for traces', () => {
+  it('redacts known key/token shapes', () => {
+    expect(redact('key sk-ant-abcdEFGH1234_- end')).not.toContain('abcdEFGH')
+    expect(redact('tok dgn_C2sMFq5KXYPBrku7kfL3S_Ao end')).not.toContain('C2sMFq5')
+    expect(redact('ghp_0123456789abcdef0123456789abcdef0123')).toContain('[redacted]')
+    expect(redact('Cookie: gp_session=deadbeef-cafe-1234')).not.toContain('deadbeef')
+  })
+  it('leaves ordinary text alone', () => {
+    expect(redact('the quick brown fox')).toBe('the quick brown fox')
+  })
+})
+
+describe('guardPath — working-dir confinement', () => {
+  const cwd = process.cwd()
+  it('marks in-cwd paths as inside', () => {
+    expect(guardPath(cwd, 'src/index.ts').outside).toBe(false)
+    expect(guardPath(cwd, './package.json').outside).toBe(false)
+  })
+  it('marks outside-cwd absolute/relative paths as outside', () => {
+    expect(guardPath(cwd, '/etc/passwd').outside).toBe(true)
+    expect(guardPath(cwd, '../../../../etc/hosts').outside).toBe(true)
+  })
+  it('flags protected credential paths regardless of location', () => {
+    expect(guardPath(cwd, `${process.env.HOME}/.ssh/id_rsa`).protectedPath).toBe(true)
+    expect(guardPath(cwd, `${process.env.HOME}/.dragon/config.json`).protectedPath).toBe(true)
+    expect(guardPath(cwd, '.env').protectedPath).toBe(true)
+    expect(guardPath(cwd, 'secrets.pem').protectedPath).toBe(true)
+  })
+})
+
+describe('resolveProvider — brain selection', () => {
+  it('defaults to claude when unset', () => {
+    delete process.env.DRAGON_BRAIN
+    expect(['claude', 'worker', 'local', 'openai', 'ghost']).toContain(resolveProvider())
+  })
+  it('honors an explicit override', () => {
+    expect(resolveProvider('worker')).toBe('worker')
+    expect(resolveProvider('bogus')).toBe('claude') // unknown → safe default
+  })
+})

package/test/skills.test.ts

@@ -0,0 +1,38 @@
+/**
+ * Skills-as-tools: frontmatter parsing + library behavior. Deterministic unit tests
+ * for the parser; the live-library checks stay environment-agnostic (the skill dir
+ * isn't in CI), asserting only sane types so the gate is portable.
+ */
+import { describe, it, expect } from 'vitest'
+import { parseFrontmatter, loadSkillLibrary } from '../dist/agent/skills.js'
+
+describe('parseFrontmatter', () => {
+  it('parses inline name + description', () => {
+    const r = parseFrontmatter('---\nname: foo-bar\ndescription: A short description here\n---\nbody text')
+    expect(r.name).toBe('foo-bar')
+    expect(r.description).toBe('A short description here')
+  })
+  it('parses a folded (>-) multi-line description', () => {
+    const r = parseFrontmatter('---\nname: my-skill\ndescription: >-\n  line one of the\n  folded description\nuser-invocable: true\n---\n')
+    expect(r.name).toBe('my-skill')
+    expect(r.description).toBe('line one of the folded description')
+  })
+  it('strips quotes and tolerates no frontmatter', () => {
+    expect(parseFrontmatter('---\nname: "quoted"\n---').name).toBe('quoted')
+    expect(parseFrontmatter('no frontmatter at all').name).toBeUndefined()
+  })
+})
+
+describe('SkillLibrary', () => {
+  const lib = loadSkillLibrary() // never throws; empty if no skill dirs
+  it('loads without throwing and reports a count', () => {
+    expect(lib.count).toBeGreaterThanOrEqual(0)
+  })
+  it('search returns an array (and is empty for nonsense)', () => {
+    expect(Array.isArray(lib.search('xyzzy-nonexistent-term'))).toBe(true)
+    expect(lib.search('').length).toBe(0)
+  })
+  it('read returns null for an unknown skill', () => {
+    expect(lib.read('definitely-not-a-real-skill-name-9000')).toBeNull()
+  })
+})

package/test/ui.test.ts

@@ -0,0 +1,46 @@
+/**
+ * Sub-cell data-viz tests (the Braille/block terminal-graphics layer in ui.ts).
+ * Run against the built output: `npm run build && vitest run`. Colour is chalk-
+ * wrapped, so we strip ANSI and assert on the visible glyphs/geometry.
+ */
+import { describe, it, expect } from 'vitest'
+import { brailleChart, sparkline, gauge } from '../dist/ui.js'
+
+const strip = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, '')
+const isBraille = /[⠀-⣿]/
+
+describe('brailleChart', () => {
+  it('returns `height` rows, each `width` visible cells wide', () => {
+    const rows = brailleChart([0, 1, 2, 3, 4, 5, 6, 7, 8], { width: 20, height: 3 })
+    expect(rows).toHaveLength(3)
+    for (const r of rows) expect([...strip(r)].length).toBe(20)
+  })
+
+  it('renders glyphs from the U+2800 Braille block for non-empty data', () => {
+    const rows = brailleChart([1, 5, 2, 8, 3, 9, 4], { width: 16, height: 3, area: true })
+    expect(isBraille.test(strip(rows.join('')))).toBe(true)
+  })
+
+  it('area fill always anchors a baseline on the bottom row', () => {
+    const rows = brailleChart([0, 0, 9, 0, 0], { width: 8, height: 3, area: true, max: 9 })
+    expect(isBraille.test(strip(rows[rows.length - 1]))).toBe(true)
+  })
+
+  it('does not throw on empty input', () => {
+    expect(() => brailleChart([], { width: 10, height: 2 })).not.toThrow()
+  })
+})
+
+describe('sparkline / gauge', () => {
+  it('sparkline maps values onto the 8 block levels', () => {
+    const s = strip(sparkline([0, 1, 2, 3, 4, 5, 6, 7]))
+    expect(s).toHaveLength(8)
+    expect(/[▁-█]/.test(s)).toBe(true)
+  })
+
+  it('gauge fills proportionally and pads to the requested width', () => {
+    const g = strip(gauge(0.5, 10))
+    expect([...g].length).toBe(10)
+    expect(g).toContain('█')
+  })
+})

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}