@mseep/claudian 2.0.25

package/manifest.json

@@ -0,0 +1,10 @@
+{
+  "id": "realclaudian",
+  "name": "Claudian",
+  "version": "2.0.25",
+  "minAppVersion": "1.7.2",
+  "description": "Embeds Claude Code, Codex, and other coding agents as AI collaborators in your vault. Your vault becomes their working directory, giving them capabilities for file reads and writes, search, bash commands, and multi-step workflows.",
+  "author": "Yishen Tu",
+  "authorUrl": "https://github.com/YishenTu",
+  "isDesktopOnly": true
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@mseep/claudian",
+  "version": "2.0.25",
+  "description": "Claudian - Claude Code embedded in Obsidian sidebar",
+  "main": "main.js",
+  "engines": {
+    "node": ">=24 <25"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.mjs",
+    "build:css": "node scripts/build-css.mjs",
+    "dev": "npm run build:css && node esbuild.config.mjs",
+    "build": "node scripts/build.mjs production",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint \"{src,tests}/**/*.ts\"",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "node scripts/run-jest.js",
+    "test:watch": "node scripts/run-jest.js --watch",
+    "test:coverage": "node scripts/run-jest.js --coverage",
+    "version": "node scripts/sync-version.js && git add manifest.json"
+  },
+  "keywords": [
+    "claude-code",
+    "obsidian",
+    "obsidian-plugin",
+    "productivity",
+    "ide",
+    "mseep",
+    "mcp-server"
+  ],
+  "author": "Yishen Tu",
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.5.2",
+    "@typescript-eslint/eslint-plugin": "^8.58.0",
+    "@typescript-eslint/parser": "^8.58.0",
+    "esbuild": "^0.28.0",
+    "eslint": "^10.2.0",
+    "eslint-plugin-jest": "^29.15.1",
+    "eslint-plugin-obsidianmd": "^0.3.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "jest": "^30.3.0",
+    "jest-environment-jsdom": "^30.3.0",
+    "obsidian": "latest",
+    "ts-jest": "^29.4.9",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.159",
+    "@codemirror/state": "^6.5.0",
+    "@codemirror/view": "^6.38.6",
+    "@modelcontextprotocol/sdk": "~1.29.0",
+    "smol-toml": "^1.6.1",
+    "tslib": "^2.8.1"
+  },
+  "overrides": {
+    "@babel/core": "7.29.7",
+    "hono": "4.12.26",
+    "js-yaml": "4.2.0"
+  },
+  "publisher": "mseep"
+}

package/scripts/build-css.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+/**
+ * CSS Build Script
+ * Concatenates modular CSS files from src/style/ into root styles.css
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
+import { join, dirname, resolve, relative } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+const STYLE_DIR = join(ROOT, 'src', 'style');
+const OUTPUT = join(ROOT, 'styles.css');
+const INDEX_FILE = join(STYLE_DIR, 'index.css');
+
+const IMPORT_PATTERN = /^\s*@import\s+(?:url\()?['"]([^'"]+)['"]\)?\s*;/gm;
+
+function getModuleOrder() {
+  if (!existsSync(INDEX_FILE)) {
+    console.error('Missing src/style/index.css');
+    process.exit(1);
+  }
+
+  const content = readFileSync(INDEX_FILE, 'utf-8');
+  const matches = [...content.matchAll(IMPORT_PATTERN)];
+
+  if (matches.length === 0) {
+    console.error('No @import entries found in src/style/index.css');
+    process.exit(1);
+  }
+
+  return matches.map((match) => match[1]);
+}
+
+function listCssFiles(dir, baseDir = dir) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const entryPath = join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      files.push(...listCssFiles(entryPath, baseDir));
+      continue;
+    }
+
+    if (entry.isFile() && entry.name.endsWith('.css')) {
+      const relativePath = relative(baseDir, entryPath).split('\\').join('/');
+      files.push(relativePath);
+    }
+  }
+
+  return files;
+}
+
+function build() {
+  const moduleOrder = getModuleOrder();
+  const parts = ['/* Claudian Plugin Styles */\n/* Built from src/style/ modules */\n'];
+  const missingFiles = [];
+  const invalidImports = [];
+  const normalizedImports = [];
+
+  for (const modulePath of moduleOrder) {
+    const resolvedPath = resolve(STYLE_DIR, modulePath);
+    const relativePath = relative(STYLE_DIR, resolvedPath);
+
+    if (relativePath.startsWith('..') || !relativePath.endsWith('.css')) {
+      invalidImports.push(modulePath);
+      continue;
+    }
+
+    const normalizedPath = relativePath.split('\\').join('/');
+    normalizedImports.push(normalizedPath);
+
+    if (!existsSync(resolvedPath)) {
+      missingFiles.push(normalizedPath);
+      continue;
+    }
+
+    const content = readFileSync(resolvedPath, 'utf-8');
+    const header = `\n/* ============================================\n   ${normalizedPath}\n   ============================================ */\n`;
+    parts.push(header + content);
+  }
+
+  let hasErrors = false;
+
+  if (invalidImports.length > 0) {
+    console.error('Invalid @import entries in src/style/index.css:');
+    invalidImports.forEach((modulePath) => console.error(`  - ${modulePath}`));
+    hasErrors = true;
+  }
+
+  if (missingFiles.length > 0) {
+    console.error('Missing CSS files:');
+    missingFiles.forEach((f) => console.error(`  - ${f}`));
+    hasErrors = true;
+  }
+
+  const allCssFiles = listCssFiles(STYLE_DIR).filter((file) => file !== 'index.css');
+  const importedSet = new Set(normalizedImports);
+  const unlistedFiles = allCssFiles.filter((file) => !importedSet.has(file));
+
+  if (unlistedFiles.length > 0) {
+    console.error('Unlisted CSS files (not imported in src/style/index.css):');
+    unlistedFiles.forEach((file) => console.error(`  - ${file}`));
+    hasErrors = true;
+  }
+
+  if (hasErrors) {
+    process.exit(1);
+  }
+
+  const output = parts.join('\n');
+  writeFileSync(OUTPUT, output);
+  console.log(`Built styles.css (${(output.length / 1024).toFixed(1)} KB)`);
+}
+
+build();

package/scripts/build.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * Combined build script - runs CSS build then esbuild
+ * Avoids npm echoing commands
+ */
+
+import { execSync } from 'child_process';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+
+// Run CSS build silently
+execSync('node scripts/build-css.mjs', { cwd: ROOT, stdio: 'inherit' });
+
+// Run esbuild with args passed through
+const args = process.argv.slice(2).join(' ');
+execSync(`node esbuild.config.mjs ${args}`, { cwd: ROOT, stdio: 'inherit' });

package/scripts/postinstall.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * Post-install script - copies .env.local.example to .env.local if it doesn't exist
+ */
+
+import { copyFileSync, existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+// Skip in CI environments
+if (process.env.CI) {
+  process.exit(0);
+}
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+
+const example = join(ROOT, '.env.local.example');
+const target = join(ROOT, '.env.local');
+
+if (existsSync(example) && !existsSync(target)) {
+  copyFileSync(example, target);
+  console.log('Created .env.local from .env.local.example');
+  console.log('Edit it to set your OBSIDIAN_VAULT path for auto-copy during development.');
+}

package/scripts/rendererSafeUnref.js

@@ -0,0 +1,205 @@
+const JS_IDENTIFIER = '[A-Za-z_$][A-Za-z0-9_$]*';
+
+const UNSAFE_TIMER_UNREF_PATTERNS = [
+  {
+    name: 'claude-sdk-process-transport-close-async',
+    pattern: new RegExp(
+      `if \\((${JS_IDENTIFIER}) && !\\1\\.killed && \\1\\.exitCode === null\\) setTimeout\\(\\((${JS_IDENTIFIER}), (${JS_IDENTIFIER})\\) => \\{\\s*` +
+      `if \\(\\2\\.exitCode !== null\\) \\{\\s*` +
+      `\\3\\(\\);\\s*` +
+      `return;\\s*` +
+      `\\}\\s*` +
+      `if \\(process\\.platform === "win32"\\) \\{\\s*` +
+      `setTimeout\\(\\((${JS_IDENTIFIER}), (${JS_IDENTIFIER})\\) => \\{\\s*` +
+      `if \\(\\4\\.exitCode === null\\) \\4\\.kill\\("SIGKILL"\\);\\s*` +
+      `\\5\\(\\);\\s*` +
+      `\\}, 5e3, \\2, \\3\\)\\.unref\\(\\);\\s*` +
+      `return;\\s*` +
+      `\\}\\s*` +
+      `\\2\\.kill\\("SIGTERM"\\), setTimeout\\(\\((${JS_IDENTIFIER})\\) => \\{\\s*` +
+      `if \\(\\6\\.exitCode === null\\) \\6\\.kill\\("SIGKILL"\\);\\s*` +
+      `\\}, 5e3, \\2\\)\\.unref\\(\\), \\3\\(\\);\\s*` +
+      `\\}, (${JS_IDENTIFIER}), \\1, (${JS_IDENTIFIER})\\)\\.unref\\(\\), \\1\\.once\\("exit", (\\(\\) => (?:\\{[^{}]*\\}|[^;{}]+))\\);`,
+      'g',
+    ),
+    replacement:
+      'if ($1 && !$1.killed && $1.exitCode === null) {' +
+      '\n      const processKillTimer = setTimeout(($2, $3) => {' +
+      '\n        if ($2.exitCode !== null) {' +
+      '\n          $3();' +
+      '\n          return;' +
+      '\n        }' +
+      '\n        if (process.platform === "win32") {' +
+      '\n          const windowsForceKillTimer = setTimeout(($4, $5) => {' +
+      '\n            if ($4.exitCode === null) $4.kill("SIGKILL");' +
+      '\n            $5();' +
+      '\n          }, 5e3, $2, $3);' +
+      '\n          windowsForceKillTimer.unref?.();' +
+      '\n          return;' +
+      '\n        }' +
+      '\n        $2.kill("SIGTERM");' +
+      '\n        const forceKillTimer = setTimeout(($6) => {' +
+      '\n          if ($6.exitCode === null) $6.kill("SIGKILL");' +
+      '\n        }, 5e3, $2);' +
+      '\n        forceKillTimer.unref?.();' +
+      '\n        $3();' +
+      '\n      }, $7, $1, $8);' +
+      '\n      processKillTimer.unref?.();' +
+      '\n      $1.once("exit", $9);' +
+      '\n    }',
+  },
+  {
+    name: 'claude-sdk-process-transport-close',
+    pattern: new RegExp(
+      `if \\((${JS_IDENTIFIER}) && !\\1\\.killed && \\1\\.exitCode === null\\) setTimeout\\(\\((${JS_IDENTIFIER})\\) => \\{\\s*` +
+      `if \\(\\2\\.killed \\|\\| \\2\\.exitCode !== null\\) return;\\s*` +
+      `\\2\\.kill\\("SIGTERM"\\), setTimeout\\(\\((${JS_IDENTIFIER})\\) => \\{\\s*` +
+      `if \\(\\3\\.exitCode === null\\) \\3\\.kill\\("SIGKILL"\\);\\s*` +
+      `\\}, 5e3, \\2\\)\\.unref\\(\\);\\s*` +
+      `\\}, (${JS_IDENTIFIER}), \\1\\)\\.unref\\(\\), \\1\\.once\\("exit", (\\(\\) => (?:\\{[^{}]*\\}|[^;{}]+))\\);`,
+      'g',
+    ),
+    replacement:
+      'if ($1 && !$1.killed && $1.exitCode === null) {' +
+      '\n      const processKillTimer = setTimeout(($2) => {' +
+      '\n        if ($2.killed || $2.exitCode !== null) return;' +
+      '\n        $2.kill("SIGTERM");' +
+      '\n        const forceKillTimer = setTimeout(($3) => {' +
+      '\n          if ($3.exitCode === null) $3.kill("SIGKILL");' +
+      '\n        }, 5e3, $2);' +
+      '\n        forceKillTimer.unref?.();' +
+      '\n      }, $4, $1);' +
+      '\n      processKillTimer.unref?.();' +
+      '\n      $1.once("exit", $5);' +
+      '\n    }',
+  },
+  {
+    name: 'mcp-sdk-stdio-close-wait',
+    pattern: /new Promise\(\((resolve\d+)\) => setTimeout\(\1, 2e3\)\.unref\(\)\)/g,
+    replacement:
+      'new Promise(($1) => {' +
+      '\n        const closeTimeout = setTimeout($1, 2e3);' +
+      '\n        closeTimeout.unref?.();' +
+      '\n      })',
+  },
+];
+
+const TIMER_CALL_PREFIXES = ['setTimeout(', 'setInterval('];
+
+function patchRendererUnsafeUnrefSites(contents) {
+  let nextContents = contents;
+  const appliedPatches = [];
+
+  for (const patch of UNSAFE_TIMER_UNREF_PATTERNS) {
+    const matchCount = [...nextContents.matchAll(patch.pattern)].length;
+    if (matchCount === 0) {
+      continue;
+    }
+    nextContents = nextContents.replace(patch.pattern, patch.replacement);
+    appliedPatches.push({ name: patch.name, count: matchCount });
+  }
+
+  return {
+    contents: nextContents,
+    appliedPatches,
+  };
+}
+
+function findUnsafeTimerUnrefSites(contents) {
+  const matches = [];
+
+  let searchIndex = 0;
+  while (searchIndex < contents.length) {
+    const timerStart = findNextTimerCall(contents, searchIndex);
+    if (!timerStart) {
+      break;
+    }
+
+    const callEnd = findMatchingParen(contents, timerStart.openParenIndex);
+    if (callEnd === -1) {
+      searchIndex = timerStart.startIndex + timerStart.prefix.length;
+      continue;
+    }
+
+    const unrefMatch = contents.slice(callEnd + 1).match(/^\s*\.unref\(\)/);
+    if (unrefMatch) {
+      const startIndex = timerStart.startIndex;
+      const endIndex = callEnd + 1 + unrefMatch[0].length;
+      const line = contents.slice(0, startIndex).split('\n').length;
+      matches.push({
+        line,
+        snippet: contents.slice(startIndex, endIndex),
+      });
+      searchIndex = endIndex;
+      continue;
+    }
+
+    searchIndex = callEnd + 1;
+  }
+
+  return matches;
+}
+
+function findNextTimerCall(contents, startIndex) {
+  let nextMatch = null;
+
+  for (const prefix of TIMER_CALL_PREFIXES) {
+    const index = contents.indexOf(prefix, startIndex);
+    if (index === -1) {
+      continue;
+    }
+    if (!nextMatch || index < nextMatch.startIndex) {
+      nextMatch = {
+        prefix,
+        startIndex: index,
+        openParenIndex: index + prefix.length - 1,
+      };
+    }
+  }
+
+  return nextMatch;
+}
+
+function findMatchingParen(contents, openParenIndex) {
+  let depth = 1;
+  let quote = null;
+
+  for (let index = openParenIndex + 1; index < contents.length; index += 1) {
+    const char = contents[index];
+
+    if (quote) {
+      if (char === '\\') {
+        index += 1;
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === '\'' || char === '`') {
+      quote = char;
+      continue;
+    }
+
+    if (char === '(') {
+      depth += 1;
+      continue;
+    }
+
+    if (char === ')') {
+      depth -= 1;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+
+  return -1;
+}
+
+module.exports = {
+  findUnsafeTimerUnrefSites,
+  patchRendererUnsafeUnrefSites,
+};

package/scripts/run-jest.js

@@ -0,0 +1,19 @@
+const { spawnSync } = require('child_process');
+const os = require('os');
+const path = require('path');
+
+const jestPath = require.resolve('jest/bin/jest');
+const localStorageFile = path.join(os.tmpdir(), 'claudian-localstorage');
+
+const result = spawnSync(
+  process.execPath,
+  [`--localstorage-file=${localStorageFile}`, jestPath, ...process.argv.slice(2)],
+  { stdio: 'inherit' }
+);
+
+if (result.error) {
+  console.error(result.error);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);

package/scripts/sync-version.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const packagePath = path.join(__dirname, '..', 'package.json');
+const manifestPath = path.join(__dirname, '..', 'manifest.json');
+
+const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+const manifestJson = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+manifestJson.version = packageJson.version;
+
+fs.writeFileSync(manifestPath, JSON.stringify(manifestJson, null, 2) + '\n');
+
+console.log(`Synced version to ${packageJson.version}`);