webspresso 0.0.95 → 0.0.97

package/src/services/builtins/file-manager.js

@@ -0,0 +1,178 @@
+/**
+ * Built-in File Manager Services
+ * @module src/services/builtins/file-manager
+ */
+
+const path = require('path');
+const fs = require('fs/promises');
+const { z } = require('zod');
+const { ValidationError, NotFoundError } = require('../../../core/errors');
+const {
+  listFiles,
+  createDirectory,
+  renameItem,
+  deleteItem,
+  moveItem,
+  saveUploadedFile,
+} = require('../../../plugins/file-manager/core');
+const { parseBase64 } = require('./media');
+
+/**
+ * Create built-in file manager services map
+ * @param {Object} [options]
+ * @param {string} [options.baseDir]
+ * @param {string} [options.publicBasePath]
+ * @returns {Record<string, Object>}
+ */
+function createFileManagerServices(options = {}) {
+  const defaultBaseDir = path.resolve(
+    options.baseDir || path.join(process.cwd(), 'public', 'uploads')
+  );
+  const defaultPublicBase = options.publicBasePath || '/uploads';
+
+  return {
+    'fileManager.list': {
+      schema: z.object({
+        path: z.string().optional().default(''),
+        search: z.string().optional(),
+        type: z.string().optional(),
+        sort: z.enum(['name', 'size', 'mtime', 'ext']).optional().default('name'),
+        order: z.enum(['asc', 'desc']).optional().default('asc'),
+        page: z.number().int().positive().optional(),
+        perPage: z.number().int().positive().optional(),
+        baseDir: z.string().optional(),
+        publicBasePath: z.string().optional(),
+      }),
+      async handler(input) {
+        const baseDir = input.baseDir ? path.resolve(input.baseDir) : defaultBaseDir;
+        const publicBasePath = input.publicBasePath || defaultPublicBase;
+
+        return listFiles(baseDir, input.path, {
+          search: input.search,
+          type: input.type,
+          sort: input.sort,
+          order: input.order,
+          page: input.page,
+          perPage: input.perPage,
+          publicBasePath,
+        });
+      },
+    },
+
+    'fileManager.mkdir': {
+      schema: z.object({
+        path: z.string().optional().default(''),
+        name: z.string().min(1, 'Directory name is required'),
+        baseDir: z.string().optional(),
+      }),
+      async handler(input) {
+        const baseDir = input.baseDir ? path.resolve(input.baseDir) : defaultBaseDir;
+        return createDirectory(baseDir, input.path, input.name);
+      },
+    },
+
+    'fileManager.rename': {
+      schema: z.object({
+        path: z.string().min(1, 'Target path is required'),
+        newName: z.string().min(1, 'New name is required'),
+        baseDir: z.string().optional(),
+      }),
+      async handler(input) {
+        const baseDir = input.baseDir ? path.resolve(input.baseDir) : defaultBaseDir;
+        return renameItem(baseDir, input.path, input.newName);
+      },
+    },
+
+    'fileManager.delete': {
+      schema: z.object({
+        path: z.string().min(1, 'Path is required'),
+        baseDir: z.string().optional(),
+      }),
+      async handler(input) {
+        const baseDir = input.baseDir ? path.resolve(input.baseDir) : defaultBaseDir;
+        return deleteItem(baseDir, input.path);
+      },
+    },
+
+    'fileManager.move': {
+      schema: z.object({
+        source: z.string().min(1, 'Source path is required'),
+        destination: z.string().optional().default(''),
+        baseDir: z.string().optional(),
+      }),
+      async handler(input) {
+        const baseDir = input.baseDir ? path.resolve(input.baseDir) : defaultBaseDir;
+        return moveItem(baseDir, input.source, input.destination);
+      },
+    },
+
+    'fileManager.upload': {
+      schema: z.object({
+        path: z.string().optional().default(''),
+        buffer: z.any().optional(),
+        base64: z.string().optional(),
+        filePath: z.string().optional(),
+        originalName: z.string().min(1).default('upload.bin'),
+        mimeType: z.string().optional(),
+        baseDir: z.string().optional(),
+        publicBasePath: z.string().optional(),
+      }),
+      async handler(input) {
+        let {
+          path: targetRelPath,
+          buffer,
+          base64,
+          filePath,
+          originalName,
+          mimeType,
+          baseDir: customBaseDir,
+          publicBasePath: customPublicBase,
+        } = input;
+        const baseDir = customBaseDir ? path.resolve(customBaseDir) : defaultBaseDir;
+        const publicBasePath = customPublicBase || defaultPublicBase;
+
+        if (buffer && !(buffer instanceof Buffer) && !(buffer instanceof Uint8Array)) {
+          if (typeof buffer === 'string') {
+            buffer = Buffer.from(buffer);
+          } else {
+            throw new ValidationError('Invalid buffer provided');
+          }
+        }
+
+        if (!buffer && base64) {
+          const parsed = parseBase64(base64);
+          buffer = parsed.buffer;
+          if (parsed.mimeType && (!mimeType || mimeType === 'application/octet-stream')) {
+            mimeType = parsed.mimeType;
+          }
+        } else if (!buffer && filePath) {
+          try {
+            buffer = await fs.readFile(path.resolve(filePath));
+            if (!originalName || originalName === 'upload.bin') {
+              originalName = path.basename(filePath);
+            }
+          } catch (err) {
+            throw new NotFoundError(`Source file not found: ${filePath}`, { cause: err });
+          }
+        }
+
+        if (!buffer || buffer.length === 0) {
+          throw new ValidationError('No file content provided');
+        }
+
+        return saveUploadedFile(
+          baseDir,
+          targetRelPath,
+          buffer,
+          originalName,
+          mimeType,
+          publicBasePath
+        );
+      },
+    },
+  };
+}
+
+module.exports = {
+  createFileManagerServices,
+};

package/src/services/discovery.js

@@ -16,7 +16,12 @@ const VALID_EXTENSIONS = new Set(['.js', '.mjs', '.cjs']);
  * @returns {string}
  */
 function toCamelCase(str) {
-  return str.replace(/[-_]+([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
+  if (!str) return '';
+  const parts = str.split(/[-_]+/);
+  return parts.map((part, index) => {
+    if (!part) return '';
+    return index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1);
+  }).join('');
 }
 
 /**

package/src/services/index.js

@@ -40,22 +40,17 @@ function createServiceRegistry(options = {}) {
   return registry;
 }
 
-const { createAuthServices } = require('./builtins/auth');
-const { createMailServices } = require('./builtins/mail');
-const { createMediaServices } = require('./builtins/media');
-const { createSystemServices } = require('./builtins/system');
-const { createExchangeServices } = require('./builtins/exchange');
-
 module.exports = {
   ServiceRegistry,
   createServiceRegistry,
   defineService,
   service: defineService, // alias
-  createAuthServices,
-  createMailServices,
-  createMediaServices,
-  createSystemServices,
-  createExchangeServices,
+  get createAuthServices() { return require('./builtins/auth').createAuthServices; },
+  get createMailServices() { return require('./builtins/mail').createMailServices; },
+  get createMediaServices() { return require('./builtins/media').createMediaServices; },
+  get createFileManagerServices() { return require('./builtins/file-manager').createFileManagerServices; },
+  get createSystemServices() { return require('./builtins/system').createSystemServices; },
+  get createExchangeServices() { return require('./builtins/exchange').createExchangeServices; },
   memoize,
   parseTtlMs,
   stableCacheKey,

package/bin/commands/skill.js

@@ -1,187 +0,0 @@
-/**
- * Skill Command — scaffold Agent Skill (SKILL.md) for Cursor / AI tools
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-let _inquirer;
-const inquirer = {
-  prompt: (...args) => {
-    if (!_inquirer) _inquirer = require('inquirer');
-    return _inquirer.prompt(...args);
-  },
-};
-
-const NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$|^[a-z0-9]$/;
-
-function validateSkillName(name) {
-  const t = String(name).trim().toLowerCase();
-  if (!t) return 'Skill name is required';
-  if (t.length > 64) return 'Skill name must be at most 64 characters';
-  if (!NAME_PATTERN.test(t)) {
-    return 'Use lowercase letters, numbers, and hyphens only (e.g. my-skill-name)';
-  }
-  return true;
-}
-
-function skillDir(base, skillName) {
-  return path.join(base, '.agents', 'skills', skillName);
-}
-
-
-function defaultDescription(skillName) {
-  const label = skillName.replace(/-/g, ' ');
-  return `Guides the agent through tasks for ${label}. Use when the user works on ${label} or asks about related workflows.`;
-}
-
-/** Bundled presets: CLI flag → template directory (all *.md copied) */
-const PRESETS = {
-  webspresso: {
-    skillName: 'webspresso-usage',
-    templateDir: path.join(__dirname, '../../templates/skills/webspresso-usage'),
-  },
-};
-
-function buildSkillMarkdown(skillName, description) {
-  const title = skillName
-    .split('-')
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-    .join(' ');
-  const descYaml = JSON.stringify(description.trim());
-
-  return `---
-name: ${skillName}
-description: ${descYaml}
----
-
-# ${title}
-
-## Instructions
-
-- Describe step-by-step what the agent should do.
-- Add constraints, file paths, and conventions for this project.
-
-## When to use
-
-- List concrete user phrases or tasks that should trigger this skill.
-
-## Examples
-
-\`\`\`
-Example prompt or command
-\`\`\`
-
-`;
-
-}
-
-function registerCommand(program) {
-  program
-    .command('skill [name]')
-    .description('Create an Agent Skill folder with SKILL.md')
-    .option('-g, --global', 'Write to ~/.agents/skills/ instead of ./.agents/skills/')
-    .option('-d, --description <text>', 'Skill description (for YAML frontmatter)')
-    .option('-f, --force', 'Overwrite existing SKILL.md')
-    .option(
-      '-p, --preset <name>',
-      'Install bundled skill: webspresso → agent reference (SKILL.md + REFERENCE-*.md in .agents/skills/webspresso-usage/)',
-    )
-
-    .action(async (nameArg, options) => {
-      const presetKey = options.preset ? String(options.preset).trim().toLowerCase() : '';
-
-      if (presetKey) {
-        const preset = PRESETS[presetKey];
-        if (!preset) {
-          console.error(`❌ Unknown preset "${presetKey}". Available: ${Object.keys(PRESETS).join(', ')}`);
-          process.exit(1);
-        }
-        const templateDir = preset.templateDir;
-        if (!templateDir || !fs.existsSync(templateDir)) {
-          console.error(`❌ Preset template directory missing: ${templateDir}`);
-          process.exit(1);
-        }
-        const mdFiles = fs
-          .readdirSync(templateDir)
-          .filter((f) => f.endsWith('.md'));
-        if (mdFiles.length === 0) {
-          console.error(`❌ No .md files in preset: ${templateDir}`);
-          process.exit(1);
-        }
-        const root = options.global ? os.homedir() : process.cwd();
-        const dir = skillDir(root, preset.skillName);
-        const skillFile = path.join(dir, 'SKILL.md');
-
-        if (!options.force && fs.existsSync(skillFile)) {
-          console.error(`❌ Already exists: ${skillFile}`);
-          console.error('   Use --force to overwrite.');
-          process.exit(1);
-        }
-
-        fs.mkdirSync(dir, { recursive: true });
-        for (const file of mdFiles) {
-          fs.copyFileSync(path.join(templateDir, file), path.join(dir, file));
-        }
-
-        console.log(`\n✅ Installed bundled skill "${presetKey}" →\n   ${dir}/\n`);
-        console.log(`   Files: ${mdFiles.join(', ')}\n`);
-        console.log('   Edit if needed, then restart Cursor or reload the window.\n');
-        return;
-      }
-
-      let skillName = nameArg ? String(nameArg).trim().toLowerCase() : '';
-
-      if (!skillName) {
-        const { name } = await inquirer.prompt([
-          {
-            type: 'input',
-            name: 'name',
-            message: 'Skill name (kebab-case, e.g. review-api):',
-            validate: validateSkillName,
-          },
-        ]);
-        skillName = name.trim().toLowerCase();
-      } else {
-        const v = validateSkillName(skillName);
-        if (v !== true) {
-          console.error(`❌ ${v}`);
-          process.exit(1);
-        }
-        skillName = skillName.trim().toLowerCase();
-      }
-
-      let description = options.description;
-      if (!description) {
-        const { desc } = await inquirer.prompt([
-          {
-            type: 'input',
-            name: 'desc',
-            message: 'Short description (what/when the agent should use this skill):',
-            default: defaultDescription(skillName),
-          },
-        ]);
-        description = desc || defaultDescription(skillName);
-      }
-
-      const root = options.global ? os.homedir() : process.cwd();
-      const dir = skillDir(root, skillName);
-      const skillFile = path.join(dir, 'SKILL.md');
-
-      if (!options.force && fs.existsSync(skillFile)) {
-        console.error(`❌ Already exists: ${skillFile}`);
-        console.error('   Use --force to overwrite.');
-        process.exit(1);
-      }
-
-      fs.mkdirSync(dir, { recursive: true });
-
-      const body = buildSkillMarkdown(skillName, description);
-      fs.writeFileSync(skillFile, body, 'utf8');
-
-      console.log(`\n✅ Agent skill created:\n   ${skillFile}\n`);
-      console.log('   Edit SKILL.md, then restart Cursor or reload the window if needed.\n');
-    });
-}
-
-module.exports = { registerCommand };