obsidian-plugin-config 1.7.2 → 1.7.5

package/scripts/utils.ts

@@ -1,151 +1,173 @@
-import { access, mkdir, copyFile, rm } from 'fs/promises';
-import path from 'path';
-import * as readline from 'readline';
-import { execSync } from 'child_process';
-
-export function createReadlineInterface(): readline.Interface {
-  return readline.createInterface({
-    input: process.stdin as NodeJS.ReadableStream,
-    output: process.stdout as NodeJS.WritableStream
-  });
-}
-
-export const askQuestion = async (
-  question: string,
-  rl: readline.Interface
-): Promise<string> => {
-  try {
-    return await new Promise((resolve) =>
-      rl.question(question, (input) => resolve(input.trim()))
-    );
-  } catch (error) {
-    console.error('Error asking question:', error);
-    throw error;
-  }
-};
-
-/**
- * Ask a yes/no confirmation question with standardized logic
- * Accepts: y, yes, Y, YES, or empty (default to yes)
- * Rejects: n, no, N, NO
- * Invalid input defaults to no for safety
- */
-export const askConfirmation = async (
-  question: string,
-  rl: readline.Interface
-): Promise<boolean> => {
-  const answer = await askQuestion(`${question} [Y/n]: `, rl);
-  const response = answer.toLowerCase();
-
-  // Accept: y, yes, Y, YES, or empty (default to yes)
-  // Reject: n, no, N, NO
-  const isYes = response === '' || response === 'y' || response === 'yes';
-  const isNo = response === 'n' || response === 'no';
-
-  if (isNo) {
-    return false;
-  } else if (isYes) {
-    return true;
-  } else {
-    console.log('Please answer Y (yes) or n (no). Defaulting to no for safety.');
-    return false;
-  }
-};
-
-export const cleanInput = (inputStr: string): string => {
-  if (!inputStr) return '';
-  return inputStr.trim().replace(/["`]/g, "'").replace(/\r\n/g, '\n');
-};
-
-export const isValidPath = async (pathToCheck: string): Promise<boolean> => {
-  if (!pathToCheck) return false;
-
-  try {
-    // Using async fs.access is preferred over synchronous existsSync
-    // as it doesn't block the main thread/event loop
-    await access(pathToCheck.trim());
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-export async function copyFilesToTargetDir(buildPath: string): Promise<void> {
-  const pluginDir = process.cwd();
-  const manifestSrc = path.join(pluginDir, 'manifest.json');
-  const manifestDest = path.join(buildPath, 'manifest.json');
-  const cssDest = path.join(buildPath, 'styles.css');
-  const folderToRemove = path.join(buildPath, '_.._');
-
-  try {
-    await mkdir(buildPath, { recursive: true });
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
-      console.error(`Error creating directory: ${(error as Error).message}`);
-    }
-  }
-
-  // Copy manifest
-  try {
-    await copyFile(manifestSrc, manifestDest);
-  } catch (error: unknown) {
-    console.error(`Error copying manifest: ${(error as Error).message}`);
-  }
-
-  // Copy CSS
-  try {
-    const srcStylesPath = path.join(pluginDir, 'src/styles.css');
-    const rootStylesPath = path.join(pluginDir, 'styles.css');
-
-    // First check if CSS exists in src/styles.css
-    if (await isValidPath(srcStylesPath)) {
-      await copyFile(srcStylesPath, cssDest);
-    }
-    // Otherwise, check if it exists in the root
-    else if (await isValidPath(rootStylesPath)) {
-      await copyFile(rootStylesPath, cssDest);
-      if (await isValidPath(folderToRemove)) {
-        await rm(folderToRemove, { recursive: true });
-      }
-    } else {
-      return;
-    }
-  } catch (error: unknown) {
-    console.error(`Error copying CSS: ${(error as Error).message}`);
-  }
-}
-
-export function gitExec(command: string): void {
-  try {
-    execSync(command, { stdio: 'inherit' });
-  } catch (error: unknown) {
-    console.error(`Error executing '${command}':`, (error as Error).message);
-    throw error;
-  }
-}
-
-/**
- * Ensure Git repository is synchronized with remote before pushing
- */
-export async function ensureGitSync(): Promise<void> {
-  try {
-    console.log('🔄 Checking Git synchronization...');
-
-    // Fetch latest changes from remote
-    execSync('git fetch origin', { stdio: 'pipe' });
-
-    // Check if branch is behind remote
-    const status = execSync('git status --porcelain -b', { encoding: 'utf8' });
-
-    if (status.includes('behind')) {
-      console.log('📥 Branch behind remote. Pulling changes...');
-      execSync('git pull', { stdio: 'inherit' });
-      console.log('✅ Successfully pulled remote changes');
-    } else {
-      console.log('✅ Repository is synchronized with remote');
-    }
-  } catch (error: unknown) {
-    console.error(`❌ Git sync failed: ${(error as Error).message}`);
-    throw error;
-  }
-}
+import { access, mkdir, copyFile, rm } from 'fs/promises';
+import path from 'path';
+import * as readline from 'readline';
+import { execSync } from 'child_process';
+
+export function createReadlineInterface(): readline.Interface {
+  return readline.createInterface({
+    input: process.stdin as NodeJS.ReadableStream,
+    output: process.stdout as NodeJS.WritableStream
+  });
+}
+
+export const askQuestion = async (
+  question: string,
+  rl: readline.Interface
+): Promise<string> => {
+  try {
+    return await new Promise((resolve) =>
+      rl.question(question, (input) => resolve(input.trim()))
+    );
+  } catch (error) {
+    console.error('Error asking question:', error);
+    throw error;
+  }
+};
+
+/**
+ * Ask a yes/no confirmation question with standardized logic
+ * Accepts: y, yes, Y, YES, or empty (default to yes)
+ * Rejects: n, no, N, NO
+ * Invalid input defaults to no for safety
+ */
+export const askConfirmation = async (
+  question: string,
+  rl: readline.Interface
+): Promise<boolean> => {
+  const answer = await askQuestion(`${question} [Y/n]: `, rl);
+  const response = answer.toLowerCase();
+
+  // Accept: y, yes, Y, YES, or empty (default to yes)
+  // Reject: n, no, N, NO
+  const isYes = response === '' || response === 'y' || response === 'yes';
+  const isNo = response === 'n' || response === 'no';
+
+  if (isNo) {
+    return false;
+  } else if (isYes) {
+    return true;
+  } else {
+    console.log('Please answer Y (yes) or n (no). Defaulting to no for safety.');
+    return false;
+  }
+};
+
+export const cleanInput = (inputStr: string): string => {
+  if (!inputStr) return '';
+  return inputStr.trim().replace(/["`]/g, "'").replace(/\r\n/g, '\n');
+};
+
+export const isValidPath = async (pathToCheck: string): Promise<boolean> => {
+  if (!pathToCheck) return false;
+
+  try {
+    // Using async fs.access is preferred over synchronous existsSync
+    // as it doesn't block the main thread/event loop
+    await access(pathToCheck.trim());
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export async function copyFilesToTargetDir(buildPath: string): Promise<void> {
+  const pluginDir = process.cwd();
+  const manifestSrc = path.join(pluginDir, 'manifest.json');
+  const manifestDest = path.join(buildPath, 'manifest.json');
+  const cssDest = path.join(buildPath, 'styles.css');
+  const folderToRemove = path.join(buildPath, '_.._');
+
+  try {
+    await mkdir(buildPath, { recursive: true });
+  } catch (error: unknown) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
+      console.error(`Error creating directory: ${(error as Error).message}`);
+    }
+  }
+
+  // Copy manifest
+  try {
+    await copyFile(manifestSrc, manifestDest);
+  } catch (error: unknown) {
+    console.error(`Error copying manifest: ${(error as Error).message}`);
+  }
+
+  // Copy CSS
+  try {
+    const srcStylesPath = path.join(pluginDir, 'src/styles.css');
+    const rootStylesPath = path.join(pluginDir, 'styles.css');
+
+    // First check if CSS exists in src/styles.css
+    if (await isValidPath(srcStylesPath)) {
+      await copyFile(srcStylesPath, cssDest);
+    }
+    // Otherwise, check if it exists in the root
+    else if (await isValidPath(rootStylesPath)) {
+      await copyFile(rootStylesPath, cssDest);
+      if (await isValidPath(folderToRemove)) {
+        await rm(folderToRemove, { recursive: true });
+      }
+    } else {
+      return;
+    }
+  } catch (error: unknown) {
+    console.error(`Error copying CSS: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Execute a shell command.
+ * Uses shell spawning for cross-platform compatibility (Windows + Linux).
+ * @param pipe - set to true to suppress stdout/stderr output
+ */
+export function gitExec(command: string, cwd?: string, pipe = false): void {
+  try {
+    execSync(command, {
+      stdio: pipe ? 'pipe' : 'inherit',
+      shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+      cwd
+    });
+  } catch (error: unknown) {
+    console.error(`Error executing '${command}':`, (error as Error).message);
+    throw error;
+  }
+}
+
+/**
+ * Execute a shell command and return its stdout as a trimmed string.
+ * Uses shell spawning for cross-platform compatibility (Windows + Linux).
+ */
+export function gitOutput(command: string, cwd?: string): string {
+  const result = execSync(command, {
+    encoding: 'utf8',
+    shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+    cwd
+  });
+  return result.trim();
+}
+
+/**
+ * Ensure Git repository is synchronized with remote before pushing
+ */
+export async function ensureGitSync(): Promise<void> {
+  try {
+    console.log('🔄 Checking Git synchronization...');
+
+    // Fetch latest changes from remote
+    gitExec('git fetch origin');
+
+    // Check if branch is behind remote
+    const status = gitOutput('git status --porcelain -b');
+
+    if (status.includes('behind')) {
+      console.log('📥 Branch behind remote. Pulling changes...');
+      gitExec('git pull');
+      console.log('✅ Successfully pulled remote changes');
+    } else {
+      console.log('✅ Repository is synchronized with remote');
+    }
+  } catch (error: unknown) {
+    console.error(`❌ Git sync failed: ${(error as Error).message}`);
+    throw error;
+  }
+}

package/templates/.github/workflows/release.yml

@@ -12,9 +12,9 @@ jobs:
       contents: write
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Use Node.js
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
           node-version: "22.x"
 

package/templates/.vscode/tasks.json

@@ -60,7 +60,7 @@
     {
       "label": "Obsidian Inject (no confirm)",
       "type": "shell",
-      "command": "obsidian-inject --no",
+      "command": "obsidian-inject --yes",
       "group": "build",
       "presentation": { "reveal": "always", "panel": "shared" },
       "problemMatcher": []

package/templates/{package.json → package.json.template}

@@ -25,7 +25,7 @@
   },
   "devDependencies": {
     "@types/eslint": "latest",
-    "@types/node": "latest",
+    "@types/node": "^25.9.2",
     "@typescript-eslint/eslint-plugin": "latest",
     "@typescript-eslint/parser": "latest",
     "builtin-modules": "latest",

package/templates/scripts/acp.ts

@@ -1,9 +1,9 @@
-import { execSync } from 'child_process';
 import {
   askQuestion,
   cleanInput,
   createReadlineInterface,
   gitExec,
+  gitOutput,
   ensureGitSync
 } from './utils.ts';
 
@@ -30,7 +30,7 @@ async function main(): Promise<void> {
     }
 
     // get current branch name
-    const currentBranch = execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
+    const currentBranch = gitOutput('git rev-parse --abbrev-ref HEAD');
 
     // Ensure Git is synchronized before pushing
     await ensureGitSync();

package/templates/scripts/env.ts

@@ -1,6 +1,5 @@
 import path from 'path';
-import { readFileSync } from 'fs';
-import fs from 'fs';
+import { readFile } from 'fs/promises';
 import { type Interface } from 'readline';
 import {
   isValidPath,
@@ -18,11 +17,11 @@ interface Manifest {
 
 export type { Manifest };
 
-export function checkManifest(pluginDir: string): Manifest {
+export async function checkManifest(pluginDir: string): Promise<Manifest> {
   const manifestPath = path.join(pluginDir, 'manifest.json');
 
   // Check if manifest exists (for plugin-config itself, it might not exist)
-  if (!fs.existsSync(manifestPath)) {
+  if (!(await isValidPath(manifestPath))) {
     console.log(
       '⚠️  No manifest.json found - this script is designed for Obsidian plugins'
     );
@@ -30,7 +29,7 @@ export function checkManifest(pluginDir: string): Manifest {
     process.exit(0);
   }
 
-  return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  return JSON.parse(await readFile(manifestPath, 'utf-8'));
 }
 
 /**

package/templates/scripts/esbuild.config.ts

@@ -16,7 +16,7 @@ import {
   copyFilesToTargetDir,
   createReadlineInterface,
   isValidPath,
-  removeMainCss
+  renameMainCss
 } from './utils.ts';
 import { reloadObsidian } from './reload.ts';
 
@@ -26,7 +26,7 @@ const pluginDir = process.cwd();
 // Create readline interface for prompts
 const rl: Interface = createReadlineInterface();
 
-const manifest: Manifest = checkManifest(pluginDir);
+const manifest: Manifest = await checkManifest(pluginDir);
 
 config();
 
@@ -56,11 +56,11 @@ async function createBuildContext(
             }
           })(),
           {
-            name: 'remove-main-css',
+            name: 'rename-main-css',
             setup(build: esbuild.PluginBuild): void {
               build.onEnd(async (result) => {
                 if (result.errors.length === 0) {
-                  await removeMainCss(buildPath);
+                  await renameMainCss(buildPath);
                 }
               });
             }
@@ -154,4 +154,3 @@ async function main(): Promise<void> {
 }
 
 main().catch(console.error);
-

package/templates/scripts/release.ts

@@ -1,11 +1,12 @@
 import { writeFile, stat } from 'fs/promises';
-import { execSync } from 'child_process';
 import dedent from 'dedent';
 import { join } from 'path';
 import {
   askConfirmation,
   askQuestion,
   createReadlineInterface,
+  gitExec,
+  gitOutput,
   ensureGitSync
 } from './utils.ts';
 
@@ -31,9 +32,7 @@ async function handleExistingTag(tag: string): Promise<boolean> {
   // Get the existing tag message to show to the user
   let existingMessage = '';
   try {
-    existingMessage = execSync(`git tag -l -n999 ${tag}`, {
-      encoding: 'utf8'
-    }).trim();
+    existingMessage = gitOutput(`git tag -l -n999 ${tag}`);
   } catch {
     // If we can't get the message, continue anyway
   }
@@ -51,8 +50,8 @@ async function handleExistingTag(tag: string): Promise<boolean> {
     return false;
   }
 
-  execSync(`git tag -d ${tag}`);
-  execSync(`git push origin :refs/tags/${tag}`);
+  gitExec(`git tag -d ${tag}`);
+  gitExec(`git push origin :refs/tags/${tag}`);
   console.log(`Deleted existing tag ${tag} locally and remotely.`);
   return true;
 }
@@ -62,9 +61,7 @@ async function createTag(): Promise<void> {
   const tag = `${currentVersion}`;
 
   await checkOrCreateFile(body);
-  const exists = execSync('git ls-remote --tags origin')
-    .toString()
-    .includes(`refs/tags/${tag}`);
+  const exists = gitOutput('git ls-remote --tags origin').includes(`refs/tags/${tag}`);
 
   if (exists && !(await handleExistingTag(tag))) {
     rl.close();
@@ -89,28 +86,28 @@ async function doNextSteps(message: string, tag: string): Promise<void> {
   const tagMessage = messages.map((m) => `-m "${m}"`).join(' ');
 
   try {
-    execSync('git add -A');
-    execSync('git commit -m "update tag description"');
+    gitExec('git add -A');
+    gitExec('git commit -m "update tag description"');
 
     // Ensure Git is synchronized before pushing
     await ensureGitSync();
 
-    execSync('git push');
+    gitExec('git push');
   } catch (error: unknown) {
     console.error('Error:', error instanceof Error ? error.message : String(error));
   }
   try {
-    execSync(`git tag -a ${tag} ${tagMessage}`);
+    gitExec(`git tag -a ${tag} ${tagMessage}`);
   } catch {
-    execSync(`git tag -d ${tag}`);
-    execSync(`git push origin :refs/tags/${tag}`);
+    gitExec(`git tag -d ${tag}`);
+    gitExec(`git push origin :refs/tags/${tag}`);
     console.log('Fixed');
-    execSync(`git tag -a ${tag} ${tagMessage}`);
+    gitExec(`git tag -a ${tag} ${tagMessage}`);
   }
   // Ensure Git is synchronized before pushing tag
   await ensureGitSync();
 
-  execSync(`git push origin ${tag}`);
+  gitExec(`git push origin ${tag}`);
   console.log(`Release ${tag} pushed to repo.`);
   console.log(dedent`
         with message:

package/templates/scripts/utils.ts

@@ -1,5 +1,4 @@
-import { access, mkdir, copyFile, rm, writeFile } from 'fs/promises';
-import { existsSync, readFileSync } from 'fs';
+import { access, mkdir, copyFile, rm, writeFile, rename, readFile } from 'fs/promises';
 import path from 'path';
 import * as readline from 'readline';
 import { execSync } from 'child_process';
@@ -122,9 +121,18 @@ export async function copyFilesToTargetDir(buildPath: string): Promise<void> {
   }
 }
 
-export function gitExec(command: string): void {
+/**
+ * Execute a shell command.
+ * Uses shell spawning for cross-platform compatibility (Windows + Linux).
+ * @param pipe - set to true to suppress stdout/stderr output
+ */
+export function gitExec(command: string, cwd?: string, pipe = false): void {
   try {
-    execSync(command, { stdio: 'inherit' });
+    execSync(command, {
+      stdio: pipe ? 'pipe' : 'inherit',
+      shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+      cwd
+    });
   } catch (error: unknown) {
     console.error(
       `Error executing '${command}':`,
@@ -134,6 +142,19 @@ export function gitExec(command: string): void {
   }
 }
 
+/**
+ * Execute a shell command and return its stdout as a trimmed string.
+ * Uses shell spawning for cross-platform compatibility (Windows + Linux).
+ */
+export function gitOutput(command: string, cwd?: string): string {
+  const result = execSync(command, {
+    encoding: 'utf8',
+    shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+    cwd
+  });
+  return result.trim();
+}
+
 /**
  * Ensure Git repository is synchronized with remote before pushing
  */
@@ -142,14 +163,14 @@ export async function ensureGitSync(): Promise<void> {
     console.log('🔄 Checking Git synchronization...');
 
     // Fetch latest changes from remote
-    execSync('git fetch origin', { stdio: 'pipe' });
+    gitExec('git fetch origin');
 
     // Check if branch is behind remote
-    const status = execSync('git status --porcelain -b', { encoding: 'utf8' });
+    const status = gitOutput('git status --porcelain -b');
 
     if (status.includes('behind')) {
       console.log('📥 Branch behind remote. Pulling changes...');
-      execSync('git pull', { stdio: 'inherit' });
+      gitExec('git pull');
       console.log('✅ Successfully pulled remote changes');
     } else {
       console.log('✅ Repository is synchronized with remote');
@@ -163,19 +184,20 @@ export async function ensureGitSync(): Promise<void> {
 }
 
 /**
- * Remove main.css file generated by esbuild when compiling SCSS
- * This prevents the unwanted main.css from being included in the plugin
+ * Rename main.css file generated by esbuild when compiling SCSS to styles.css
+ * This ensures the compiled CSS is correctly recognized by Obsidian
  */
-export async function removeMainCss(outdir: string): Promise<void> {
+export async function renameMainCss(outdir: string): Promise<void> {
   const mainCssPath = path.join(outdir, 'main.css');
+  const stylesCssPath = path.join(outdir, 'styles.css');
   try {
-    await rm(mainCssPath);
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-      console.warn(
-        `Warning: Could not remove main.css: ${error instanceof Error ? error.message : String(error)}`
-      );
+    if (await isValidPath(mainCssPath)) {
+      await rename(mainCssPath, stylesCssPath);
     }
+  } catch (error: unknown) {
+    console.warn(
+      `Warning: Could not rename main.css to styles.css: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
 }
 
@@ -185,22 +207,17 @@ export function isInPluginsFolder(currentPath: string): boolean {
 }
 
 /** Validates that a path points to an Obsidian vault with a plugins directory */
-export function validateVaultPath(vaultPath: string): boolean {
+export async function validateVaultPath(vaultPath: string): Promise<boolean> {
   // Normalize path to handle both forward and backward slashes
   const normalizedPath = path.normalize(vaultPath);
   return (
-    existsSync(path.join(normalizedPath, '.obsidian')) &&
-    existsSync(path.join(normalizedPath, '.obsidian', 'plugins'))
+    (await isValidPath(path.join(normalizedPath, '.obsidian'))) &&
+    (await isValidPath(path.join(normalizedPath, '.obsidian', 'plugins')))
   );
 }
 
 /** Resolves the full plugin install path from a vault path */
 export function getVaultPath(vaultPath: string, pluginId: string): string {
-  if (!validateVaultPath(vaultPath)) {
-    console.error(`❌ Invalid vault path: ${vaultPath}`);
-    console.error(`   The path must contain a .obsidian/plugins directory`);
-    process.exit(1);
-  }
   const pluginsPath = path.join('.obsidian', 'plugins');
   return vaultPath.includes(pluginsPath)
     ? path.join(vaultPath, pluginId)
@@ -215,7 +232,7 @@ export async function updateEnvFile(
 ): Promise<void> {
   let envContent = '';
   try {
-    envContent = readFileSync(envPath, 'utf8');
+    envContent = await readFile(envPath, 'utf8');
   } catch {
     /* file doesn't exist yet */
   }

package/tsconfig.json

@@ -19,6 +19,6 @@
     "resolveJsonModule": true,
     "lib": ["DOM", "ES2024"]
   },
-  "include": ["./scripts/**/*.ts"],
-  "exclude": ["node_modules", "eslint.config.ts", "templates"]
+  "include": ["./scripts/**/*.ts", "templates/**/*.ts"],
+  "exclude": ["node_modules", "eslint.config.ts"]
 }