agentic-mermaid 0.1.0 → 0.1.2

package/src/mcp/artifacts.ts

@@ -1,137 +0,0 @@
-import { createHash } from 'node:crypto'
-import { existsSync, lstatSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { basename, join, resolve, sep } from 'node:path'
-
-export interface ArtifactStoreOptions {
-  dir?: string
-  baseUrl?: string
-  maxBytes?: number
-  ttlMs?: number
-  now?: () => number
-}
-
-export interface WriteArtifactOptions {
-  extension: string
-  mimeType: string
-}
-
-export interface ArtifactRecord {
-  name: string
-  path: string
-  mimeType: string
-  bytes: number
-  sha256: string
-  url?: string
-}
-
-export interface StoredArtifact {
-  path: string
-  mimeType: string
-  bytes: Buffer
-}
-
-interface TrackedRecord extends ArtifactRecord {
-  expiresAt: number
-}
-
-const DEFAULT_MAX_BYTES = 20 * 1024 * 1024
-const DEFAULT_TTL_MS = 60 * 60 * 1000
-
-export class ArtifactStore {
-  readonly dir: string
-  readonly maxBytes: number
-  readonly ttlMs: number
-  private baseUrl?: string
-  private readonly now: () => number
-  private readonly records = new Map<string, TrackedRecord>()
-
-  constructor(opts: ArtifactStoreOptions = {}) {
-    this.dir = resolve(opts.dir ?? join(tmpdir(), 'agentic-mermaid-mcp-artifacts'))
-    this.baseUrl = normalizeBaseUrl(opts.baseUrl)
-    this.maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES
-    this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS
-    this.now = opts.now ?? (() => Date.now())
-    mkdirSync(this.dir, { recursive: true, mode: 0o700 })
-  }
-
-  setBaseUrl(baseUrl: string | undefined): void {
-    this.baseUrl = normalizeBaseUrl(baseUrl)
-  }
-
-  hasBaseUrl(): boolean { return typeof this.baseUrl === 'string' && this.baseUrl.length > 0 }
-
-  write(bytes: Uint8Array, opts: WriteArtifactOptions): ArtifactRecord {
-    if (!Number.isFinite(this.maxBytes) || this.maxBytes <= 0) throw new Error('artifact maxBytes must be a positive finite number')
-    if (bytes.byteLength > this.maxBytes) throw new Error(`artifact exceeds maxBytes (${bytes.byteLength} > ${this.maxBytes})`)
-    this.cleanupExpired()
-    const buffer = Buffer.from(bytes)
-    const sha256 = createHash('sha256').update(buffer).digest('hex')
-    const ext = sanitizeExtension(opts.extension)
-    const name = `${this.now().toString(36)}-${sha256.slice(0, 16)}${ext}`
-    const path = safePath(this.dir, name)
-    writeFileSync(path, buffer, { mode: 0o600 })
-    const record: ArtifactRecord = { name, path, mimeType: opts.mimeType, bytes: buffer.length, sha256 }
-    if (this.baseUrl) record.url = `${this.baseUrl}/${encodeURIComponent(name)}`
-    this.records.set(name, { ...record, expiresAt: this.now() + this.ttlMs })
-    return record
-  }
-
-  read(name: string): StoredArtifact | null {
-    let path: string
-    try { path = safePath(this.dir, name) } catch { return null }
-    const record = this.records.get(name)
-    if (!record || record.path !== path) return null
-    if (record.expiresAt < this.now()) {
-      this.deleteRecord(name, path)
-      return null
-    }
-    if (!existsSync(path)) {
-      this.records.delete(name)
-      return null
-    }
-    const st = lstatSync(path)
-    if (!st.isFile() || st.isSymbolicLink()) return null
-    const bytes = readFileSync(path)
-    return { path, bytes, mimeType: record.mimeType }
-  }
-
-  cleanupExpired(): void {
-    if (!existsSync(this.dir)) return
-    const cutoff = this.now()
-    for (const [name, record] of this.records) {
-      if (record.expiresAt < cutoff) this.deleteRecord(name, record.path)
-    }
-    // Untracked files are never served by read(); do not delete them because
-    // the user may have pointed --artifact-dir at a shared directory.
-  }
-
-  private deleteRecord(name: string, path: string): void {
-    this.records.delete(name)
-    try { unlinkSync(path) } catch {}
-  }
-}
-
-export function createArtifactStore(opts: ArtifactStoreOptions = {}): ArtifactStore {
-  return new ArtifactStore(opts)
-}
-
-function normalizeBaseUrl(url: string | undefined): string | undefined {
-  if (!url) return undefined
-  return url.replace(/\/+$/, '')
-}
-
-function sanitizeExtension(extension: string): string {
-  const ext = extension.startsWith('.') ? extension : `.${extension}`
-  const safe = ext.toLowerCase().replace(/[^.a-z0-9_-]/g, '')
-  return safe && safe !== '.' ? safe : '.bin'
-}
-
-function safePath(root: string, name: string): string {
-  const leaf = basename(name)
-  if (!leaf || leaf !== name || leaf.includes('..')) throw new Error('invalid artifact name')
-  const path = resolve(root, leaf)
-  const prefix = root.endsWith(sep) ? root : `${root}${sep}`
-  if (!path.startsWith(prefix)) throw new Error('artifact path escaped root')
-  return path
-}

package/src/mcp/dynamic-harness.ts

@@ -1,31 +0,0 @@
-// Entry module for the Code Mode dynamic-worker isolate. website/build.ts
-// bundles this file (plus the SDK it imports) into a single text asset that
-// the website Worker passes to the Worker Loader as `harness.js`, alongside
-// the agent code as `user.js` (one wrap variant per isolate; see
-// userModuleSources and execute-loader.ts).
-//
-// workerd compiles every module in the registry eagerly at isolate startup,
-// so a user module that does not parse fails the whole worker start — the
-// parent catches that and retries with the statement-form wrap. By the time
-// this fetch handler runs, `user.js` compiled.
-//
-// The isolate is created with `globalOutbound: null`, an empty env, and cpuMs
-// limits — the harness only has to run the code and report the result.
-
-import { runUserCode, hardenIsolateGlobals } from './harness-runtime.ts'
-
-// Run at isolate startup — BEFORE the dynamic import below evaluates user.js —
-// so a wrapper breakout into top-level module scope sees stripped capability
-// globals. This is the harness (main) module's top level; user.js is not a
-// static dependency, so it evaluates only at the `import()` in fetch(), after
-// this has run. Defense in depth on top of the isolate's `globalOutbound: null`.
-hardenIsolateGlobals()
-
-export default {
-  async fetch(): Promise<Response> {
-    // Dynamic form only because the bundler must leave the specifier alone
-    // (the module is injected per-isolate); workerd compiled it at startup.
-    const userFn = (await import('./user.js')).default
-    return new Response(JSON.stringify(runUserCode(userFn)), { headers: { 'content-type': 'application/json' } })
-  },
-}

package/src/mcp/dynamic-modules.d.ts

@@ -1,7 +0,0 @@
-// The dynamic-worker harness imports the agent-code module that exists only
-// inside the Worker Loader's module registry (supplied per-isolate by the
-// website Worker). Declare it so dynamic-harness.ts typechecks.
-declare module '*user.js' {
-  const fn: unknown
-  export default fn
-}