codesynapt 0.0.0

package/electron/plugin-loader.cjs

@@ -0,0 +1,184 @@
+// ═══════════════════════════════════════════════════════════
+//  Plugin loader — main process side
+//
+//  Responsibilities:
+//   - Discover plugin folders under the user's plugin directory
+//   - Read and validate each manifest.json
+//   - Hand the list back to the renderer; the renderer activates
+//     code plugins inside its own context (sandboxed by Electron's
+//     contextIsolation) and loads theme CSS directly.
+//
+//  The plugin directory is one of:
+//    macOS:   ~/Library/Application Support/codesynapt/plugins
+//    Windows: %APPDATA%\codesynapt\plugins
+//    Linux:   ~/.config/codesynapt/plugins
+//
+//  Each plugin is its own folder containing manifest.json plus
+//  the entry file (theme.css or main.js).
+// ═══════════════════════════════════════════════════════════
+const fs = require('fs')
+const path = require('path')
+const { app } = require('electron')
+
+const VALID_TYPES = new Set(['theme', 'exporter', 'parser', 'layout', 'panel', 'action'])
+const VALID_PERMISSIONS = new Set([
+  'read-files', 'read-graph', 'modify-graph',
+  'ui-panel', 'context-menu', 'export', 'parse'
+])
+
+// Resolve the per-OS plugin folder. We pin it under userData so the
+// app handles cross-platform paths for us.
+function getPluginDir() {
+  return path.join(app.getPath('userData'), 'plugins')
+}
+
+// Make sure the directory exists so users can drop plugins into it
+// without having to mkdir manually.
+function ensurePluginDir() {
+  const dir = getPluginDir()
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+  } catch (err) {
+    console.warn('[plugin-loader] could not create plugin dir:', err.message)
+  }
+  return dir
+}
+
+// Validate a parsed manifest against the schema. Returns either
+// { ok: true, manifest } or { ok: false, reason: string }.
+function validateManifest(raw) {
+  if (!raw || typeof raw !== 'object') return { ok: false, reason: 'not an object' }
+  const required = ['id', 'name', 'version', 'type', 'main']
+  for (const k of required) {
+    if (!raw[k] || typeof raw[k] !== 'string') {
+      return { ok: false, reason: `missing or invalid "${k}"` }
+    }
+  }
+  if (!/^[a-z0-9][a-z0-9-_]*$/i.test(raw.id)) {
+    return { ok: false, reason: `invalid id "${raw.id}" (use alphanumeric + dash/underscore)` }
+  }
+  if (!VALID_TYPES.has(raw.type)) {
+    return { ok: false, reason: `unknown type "${raw.type}"` }
+  }
+  // Permissions are optional; if present must be an array of known strings
+  if (raw.permissions !== undefined) {
+    if (!Array.isArray(raw.permissions)) {
+      return { ok: false, reason: 'permissions must be an array' }
+    }
+    for (const p of raw.permissions) {
+      if (!VALID_PERMISSIONS.has(p)) {
+        return { ok: false, reason: `unknown permission "${p}"` }
+      }
+    }
+  }
+  // Provide defaults for optional fields so the renderer doesn't
+  // have to null-check them
+  return {
+    ok: true,
+    manifest: {
+      id: raw.id,
+      name: raw.name,
+      version: raw.version,
+      author: raw.author || 'unknown',
+      description: raw.description || '',
+      type: raw.type,
+      main: raw.main,
+      minAppVersion: raw.minAppVersion || '0.0.0',
+      license: raw.license || 'unknown',
+      homepage: raw.homepage || null,
+      permissions: raw.permissions || [],
+    }
+  }
+}
+
+// Discover all plugins. Returns an array of:
+//   { manifest, folder, entryPath, entryContent?, error? }
+//
+// For theme plugins we read the CSS file directly here so the renderer
+// can just inject it. For code plugins we read the JS source string and
+// pass it to the renderer to execute in its sandbox.
+function discoverPlugins() {
+  const dir = ensurePluginDir()
+  let entries
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true })
+  } catch (err) {
+    console.warn('[plugin-loader] cannot read plugin dir:', err.message)
+    return []
+  }
+
+  const results = []
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    if (entry.name.startsWith('.') || entry.name.startsWith('_')) continue
+    const folder = path.join(dir, entry.name)
+    const manifestPath = path.join(folder, 'manifest.json')
+
+    let raw
+    try {
+      raw = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+    } catch (err) {
+      results.push({
+        folder, error: `manifest unreadable: ${err.message}`,
+        manifest: { id: entry.name, name: entry.name, type: 'unknown' }
+      })
+      continue
+    }
+
+    const validation = validateManifest(raw)
+    if (!validation.ok) {
+      results.push({
+        folder, error: `invalid manifest: ${validation.reason}`,
+        manifest: { id: raw.id || entry.name, name: raw.name || entry.name, type: raw.type || 'unknown' }
+      })
+      continue
+    }
+
+    const { manifest } = validation
+    // Security: the entry file must live inside the plugin folder.
+    // Reject anything escaping with .. or absolute paths.
+    const entryPath = path.resolve(folder, manifest.main)
+    const rel = path.relative(folder, entryPath)
+    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+      results.push({
+        folder, manifest,
+        error: `entry path escapes plugin folder: ${manifest.main}`
+      })
+      continue
+    }
+    if (!fs.existsSync(entryPath)) {
+      results.push({
+        folder, manifest,
+        error: `entry file not found: ${manifest.main}`
+      })
+      continue
+    }
+
+    let entryContent = null
+    try {
+      entryContent = fs.readFileSync(entryPath, 'utf8')
+    } catch (err) {
+      results.push({
+        folder, manifest,
+        error: `cannot read entry: ${err.message}`
+      })
+      continue
+    }
+
+    results.push({
+      folder,
+      manifest,
+      entryPath,
+      entryContent,
+      error: null,
+    })
+  }
+  return results
+}
+
+module.exports = {
+  getPluginDir,
+  ensurePluginDir,
+  discoverPlugins,
+  validateManifest,
+}

package/electron/preload.cjs

@@ -0,0 +1,108 @@
+// Preload — safe IPC bridge between renderer (untrusted) and main (privileged)
+const { contextBridge, ipcRenderer } = require('electron')
+
+const csApi = {
+  // Imperative
+  pickFolder: () => ipcRenderer.invoke('pick-folder'),
+  loadFolder: (path) => ipcRenderer.invoke('load-folder', path),
+  closeFolder: () => ipcRenderer.invoke('close-folder'),
+  getState: () => ipcRenderer.invoke('get-state'),
+  readFile: (id) => ipcRenderer.invoke('read-file', id),
+  writeFile: (id, content) => ipcRenderer.invoke('write-file', id, content),
+  listHistory: (id) => ipcRenderer.invoke('list-history', id),
+  readHistory: (id, ts) => ipcRenderer.invoke('read-history', id, ts),
+  restoreHistory: (id, ts) => ipcRenderer.invoke('restore-history', id, ts),
+  setHistoryEnabled: (enabled) => ipcRenderer.invoke('set-history-enabled', enabled),
+  getHistoryEnabled: () => ipcRenderer.invoke('get-history-enabled'),
+  controlPort: () => ipcRenderer.invoke('control-port'),
+  onControl: (cb) => {
+    const onFocus = (_e, data) => cb({ type: 'focus', ...data })
+    const onOpen  = (_e, data) => cb({ type: 'open',  ...data })
+    const onTrace = (_e, data) => cb({ type: 'trace', ...data })
+    const onBlast = (_e, data) => cb({ type: 'blast', ...data })
+    ipcRenderer.on('control:focus', onFocus)
+    ipcRenderer.on('control:open',  onOpen)
+    ipcRenderer.on('control:trace', onTrace)
+    ipcRenderer.on('control:blast', onBlast)
+    return () => {
+      ipcRenderer.off('control:focus', onFocus)
+      ipcRenderer.off('control:open',  onOpen)
+      ipcRenderer.off('control:trace', onTrace)
+      ipcRenderer.off('control:blast', onBlast)
+    }
+  },
+  revealInOS: (id) => ipcRenderer.invoke('reveal-in-os', id),
+  openInEditor: (id) => ipcRenderer.invoke('open-in-editor', id),
+
+  // Event subscriptions (main → renderer)
+  onSnapshot: (cb) => {
+    const handler = (_e, data) => cb(data)
+    ipcRenderer.on('snapshot', handler)
+    return () => ipcRenderer.off('snapshot', handler)
+  },
+  onFolderLoaded: (cb) => {
+    const handler = (_e, data) => cb(data)
+    ipcRenderer.on('folder-loaded', handler)
+    return () => ipcRenderer.off('folder-loaded', handler)
+  },
+  onNoFolder: (cb) => {
+    const handler = () => cb()
+    ipcRenderer.on('no-folder', handler)
+    return () => ipcRenderer.off('no-folder', handler)
+  },
+  onError: (cb) => {
+    const handler = (_e, data) => cb(data)
+    ipcRenderer.on('error', handler)
+    return () => ipcRenderer.off('error', handler)
+  },
+  onWindowVisibility: (cb) => {
+    const handler = (_e, data) => cb(data)
+    ipcRenderer.on('window-visibility', handler)
+    return () => ipcRenderer.off('window-visibility', handler)
+  },
+  onScanProgress: (cb) => {
+    const handler = (_e, data) => cb(data)
+    ipcRenderer.on('scan-progress', handler)
+    return () => ipcRenderer.off('scan-progress', handler)
+  },
+
+  // Panel data — bypasses fetch/CSP for tour, timeline, changes
+  getTour:       () => ipcRenderer.invoke('panel:tour'),
+  getTimeline:   () => ipcRenderer.invoke('panel:timeline'),
+  getChanges:    () => ipcRenderer.invoke('panel:changes'),
+  getChangeDiff: (id) => ipcRenderer.invoke('panel:change-diff', id),
+  getPackages:   () => ipcRenderer.invoke('panel:packages'),
+  getPackage:    (name) => ipcRenderer.invoke('panel:package', name),
+  getLegacy:     () => ipcRenderer.invoke('panel:legacy'),
+  // Trace session — live AI activity log
+  traceLog:      (opts) => ipcRenderer.invoke('trace:log', opts || {}),
+  traceStats:    () => ipcRenderer.invoke('trace:stats'),
+  traceSessions: () => ipcRenderer.invoke('trace:sessions'),
+  traceSession:  (id) => ipcRenderer.invoke('trace:session', id),
+  traceClear:    () => ipcRenderer.invoke('trace:clear'),
+  traceExport:   (path) => ipcRenderer.invoke('trace:export', path),
+
+  // Pinned projects (multi-folder workspace)
+  listProjects:   () => ipcRenderer.invoke('list-projects'),
+  pinProject:     (path, name, color) => ipcRenderer.invoke('pin-project', { path, name, color }),
+  unpinProject:   (path) => ipcRenderer.invoke('unpin-project', path),
+  renameProject:  (path, name) => ipcRenderer.invoke('rename-project', { path, name }),
+
+  // Plugin system
+  listPlugins: () => ipcRenderer.invoke('list-plugins'),
+  openPluginDir: () => ipcRenderer.invoke('open-plugin-dir'),
+  pluginDir: () => ipcRenderer.invoke('plugin-dir'),
+}
+
+// Expose under both names: 'codesynapt' is the canonical namespace from 0.14.6+;
+// 'fg3d' is a legacy alias kept for backward compat (plugin authors, etc.).
+// Both refer to the SAME object — no extra memory.
+contextBridge.exposeInMainWorld('codesynapt', csApi)
+contextBridge.exposeInMainWorld('fg3d', csApi)
+
+// Platform info for renderer
+contextBridge.exposeInMainWorld('platform', {
+  os: process.platform,
+  isMac: process.platform === 'darwin',
+  isElectron: true,
+})

package/package.json

@@ -0,0 +1,216 @@
+{
+  "name": "codesynapt",
+  "version": "0.0.0",
+  "description": "MCP-native code graph for AI agents — see blast radius live. 3D visualizer + CLI + MCP server, one package.",
+  "license": "AGPL-3.0-or-later",
+  "author": {
+    "name": "wing1008",
+    "url": "https://github.com/wing1008"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/wing1008"
+    },
+    {
+      "type": "individual",
+      "url": "https://buymeacoffee.com/wing1008"
+    }
+  ],
+  "homepage": "https://github.com/wing1008/codesynapt#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wing1008/codesynapt.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wing1008/codesynapt/issues"
+  },
+  "keywords": [
+    "code-visualization",
+    "dependency-graph",
+    "mcp",
+    "ai-coding-agent",
+    "blast-radius",
+    "3d",
+    "electron",
+    "three.js",
+    "developer-tools"
+  ],
+  "type": "module",
+  "main": "electron/main.cjs",
+  "bin": {
+    "codesynapt-server": "server.js",
+    "codesynapt": "packages/core/bin/codesynapt.cjs",
+    "cs": "packages/core/bin/codesynapt.cjs",
+    "codesynapt-mcp": "packages/core/bin/codesynapt-mcp.cjs"
+  },
+  "files": [
+    "packages/core/",
+    "electron/",
+    "public/",
+    "scripts/",
+    "plugin-api/",
+    "server.js",
+    "LICENSE",
+    "LICENSES.md",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/copy-vendor.js",
+    "start": "electron .",
+    "electron": "electron .",
+    "server": "node server.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:smoke": "node test.js",
+    "bench": "node scripts/perf-test.js",
+    "license-check": "node scripts/license-check.js",
+    "dist": "electron-builder",
+    "dist:mac": "electron-builder --mac",
+    "dist:win": "node scripts/download-bundled-node.cjs && electron-builder --win",
+    "dist:linux": "electron-builder --linux"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.24.0",
+    "@babel/traverse": "^7.24.0",
+    "chokidar": "^3.6.0",
+    "tree-sitter-wasms": "^0.1.13",
+    "typescript": "^6.0.3",
+    "web-tree-sitter": "^0.20.8"
+  },
+  "optionalDependencies": {
+    "@xenova/transformers": "^2.17.2",
+    "three": "^0.160.0",
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@electron/fuses": "^2.1.1",
+    "autocannon": "^8.0.0",
+    "clinic": "^13.0.0",
+    "electron": "^41.0.0",
+    "electron-builder": "^25.0.0",
+    "electron-updater": "^6.8.3",
+    "memlab": "^2.0.3",
+    "playwright": "^1.60.0",
+    "vitest": "^2.1.9"
+  },
+  "build": {
+    "appId": "io.codesynapt.desktop",
+    "productName": "CodeSynapt",
+    "artifactName": "${productName}-Setup-${version}.${ext}",
+    "afterPack": "scripts/fuses-after-pack.cjs",
+    "asar": false,
+    "files": [
+      "electron/**/*",
+      "public/**/*",
+      "packages/core/**/*",
+      "plugin-api/**/*",
+      "scripts/**/*",
+      "server.js",
+      "package.json"
+    ],
+    "extraResources": [
+      {
+        "from": "build/bundled-node/",
+        "to": "bundled-node/",
+        "filter": [
+          "**/*"
+        ]
+      },
+      {
+        "from": "build/installer-bin/",
+        "to": "installer-bin/",
+        "filter": [
+          "**/*"
+        ]
+      }
+    ],
+    "directories": {
+      "buildResources": "build",
+      "output": "dist"
+    },
+    "mac": {
+      "category": "public.app-category.developer-tools",
+      "target": [
+        {
+          "target": "dmg",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "zip",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        }
+      ],
+      "hardenedRuntime": true,
+      "gatekeeperAssess": false,
+      "entitlements": "build/entitlements.mac.plist",
+      "entitlementsInherit": "build/entitlements.mac.plist"
+    },
+    "win": {
+      "target": [
+        {
+          "target": "nsis",
+          "arch": [
+            "x64"
+          ]
+        }
+      ]
+    },
+    "nsis": {
+      "oneClick": false,
+      "perMachine": false,
+      "allowToChangeInstallationDirectory": true,
+      "allowElevation": false,
+      "createDesktopShortcut": true,
+      "createStartMenuShortcut": true,
+      "shortcutName": "CodeSynapt",
+      "uninstallDisplayName": "CodeSynapt ${version}",
+      "deleteAppDataOnUninstall": false,
+      "differentialPackage": false,
+      "runAfterFinish": true,
+      "include": "build/installer.nsh"
+    },
+    "linux": {
+      "target": [
+        {
+          "target": "AppImage",
+          "arch": [
+            "x64"
+          ]
+        },
+        {
+          "target": "deb",
+          "arch": [
+            "x64"
+          ]
+        },
+        {
+          "target": "tar.gz",
+          "arch": [
+            "x64"
+          ]
+        }
+      ],
+      "category": "Development",
+      "synopsis": "MCP-native code graph visualizer for AI coding agents",
+      "description": "CodeSynapt visualizes how files in a codebase connect to each other in 3D, and exposes the dependency graph to AI coding agents via MCP — so agents can see blast radius before editing."
+    },
+    "publish": [
+      {
+        "provider": "github",
+        "owner": "wing1008",
+        "repo": "codesynapt"
+      }
+    ]
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}