@orchid-labs/pluxx 0.1.0 → 0.1.1

package/src/cli/install.ts

@@ -1,4 +1,4 @@
-import { resolve, basename } from 'path'
+import { resolve, basename, dirname } from 'path'
 import { existsSync, symlinkSync, mkdirSync, rmSync, readFileSync, writeFileSync, cpSync } from 'fs'
 import { spawnSync } from 'child_process'
 import * as readline from 'readline'
@@ -30,6 +30,25 @@ interface CommandResult {
   stderr: string
 }
 
+interface CodexMarketplaceFile {
+  name?: string
+  interface?: {
+    displayName?: string
+  }
+  plugins?: Array<{
+    name: string
+    source?: {
+      source?: string
+      path?: string
+    }
+    policy?: {
+      installation?: string
+      authentication?: string
+    }
+    category?: string
+  }>
+}
+
 type CommandRunner = (command: string, args: string[]) => CommandResult
 
 export interface HookCommand {
@@ -244,8 +263,8 @@ function getInstallTargets(pluginName: string): InstallTarget[] {
     },
     {
       platform: 'codex',
-      pluginDir: resolve(home, 'plugins', pluginName),
-      description: `~/plugins/${pluginName}`,
+      pluginDir: resolve(home, '.codex/plugins', pluginName),
+      description: `~/.codex/plugins/${pluginName} (via ~/.agents/plugins/marketplace.json)`,
     },
     {
       platform: 'opencode',
@@ -290,6 +309,16 @@ function getInstallTargets(pluginName: string): InstallTarget[] {
   ]
 }
 
+export function getInstallFollowupNotes(platforms: TargetPlatform[]): string[] {
+  const notes: string[] = []
+
+  if (platforms.includes('claude-code')) {
+    notes.push('Claude Code note: if Claude is already open, run /reload-plugins in the session to pick up the new install.')
+  }
+
+  return notes
+}
+
 function runCommandDefault(command: string, args: string[]): CommandResult {
   const result = spawnSync(command, args, { encoding: 'utf-8' })
   return {
@@ -310,6 +339,90 @@ function createSymlinkInstall(target: PlannedInstallTarget): void {
   symlinkSync(target.sourceDir, target.pluginDir)
 }
 
+function getCodexMarketplacePath(): string {
+  const home = process.env.HOME ?? '~'
+  return resolve(home, '.agents/plugins/marketplace.json')
+}
+
+function getCodexMarketplacePluginPath(pluginName: string): string {
+  return `./.codex/plugins/${pluginName}`
+}
+
+function readCodexMarketplace(filepath: string): CodexMarketplaceFile {
+  if (!existsSync(filepath)) {
+    return {
+      name: 'pluxx-local',
+      interface: {
+        displayName: 'Pluxx Local',
+      },
+      plugins: [],
+    }
+  }
+
+  const raw = readFileSync(filepath, 'utf-8')
+  const parsed = JSON.parse(raw) as CodexMarketplaceFile
+  return {
+    name: parsed.name ?? 'pluxx-local',
+    interface: parsed.interface ?? { displayName: 'Pluxx Local' },
+    plugins: Array.isArray(parsed.plugins) ? parsed.plugins : [],
+  }
+}
+
+function ensureCodexMarketplace(pluginName: string): void {
+  const filepath = getCodexMarketplacePath()
+  mkdirSync(dirname(filepath), { recursive: true })
+
+  const marketplace = readCodexMarketplace(filepath)
+  const nextPlugins = (marketplace.plugins ?? []).filter((plugin) => plugin.name !== pluginName)
+  nextPlugins.push({
+    name: pluginName,
+    source: {
+      source: 'local',
+      path: getCodexMarketplacePluginPath(pluginName),
+    },
+    policy: {
+      installation: 'AVAILABLE',
+      authentication: 'ON_INSTALL',
+    },
+    category: 'Productivity',
+  })
+
+  writeFileSync(
+    filepath,
+    JSON.stringify({
+      name: marketplace.name ?? 'pluxx-local',
+      interface: marketplace.interface ?? { displayName: 'Pluxx Local' },
+      plugins: nextPlugins,
+    }, null, 2) + '\n',
+  )
+}
+
+function removeCodexMarketplacePlugin(pluginName: string): void {
+  const filepath = getCodexMarketplacePath()
+  if (!existsSync(filepath)) return
+
+  const marketplace = readCodexMarketplace(filepath)
+  const nextPlugins = (marketplace.plugins ?? []).filter((plugin) => plugin.name !== pluginName)
+
+  if (nextPlugins.length === (marketplace.plugins ?? []).length) {
+    return
+  }
+
+  if (nextPlugins.length === 0) {
+    rmSync(filepath, { force: true })
+    return
+  }
+
+  writeFileSync(
+    filepath,
+    JSON.stringify({
+      name: marketplace.name ?? 'pluxx-local',
+      interface: marketplace.interface ?? { displayName: 'Pluxx Local' },
+      plugins: nextPlugins,
+    }, null, 2) + '\n',
+  )
+}
+
 function createCopiedInstall(target: PlannedInstallTarget): void {
   const parentDir = resolve(target.pluginDir, '..')
   mkdirSync(parentDir, { recursive: true })
@@ -585,6 +698,34 @@ function installClaudePlugin(
   }
 }
 
+function uninstallClaudePlugin(
+  target: InstallTarget,
+  pluginName: string,
+  runCommand: CommandRunner,
+  options: { quiet?: boolean } = {},
+): boolean {
+  const marketplaceName = getClaudeMarketplaceName(pluginName)
+  const uninstall = runCommand('claude', ['plugin', 'uninstall', `${pluginName}@${marketplaceName}`])
+
+  if (uninstall.status !== 0 && !options.quiet) {
+    const detail = uninstall.stderr || uninstall.stdout
+    if (detail.trim().length > 0) {
+      console.warn(`  warning claude-code uninstall: ${detail.trim()}`)
+    }
+  }
+
+  const marketplaceRoot = getClaudeMarketplaceRoot(pluginName)
+  const hadMarketplaceRoot = existsSync(marketplaceRoot)
+  rmSync(marketplaceRoot, { recursive: true, force: true })
+
+  const hadLegacyPluginDir = existsSync(target.pluginDir)
+  if (hadLegacyPluginDir) {
+    rmSync(target.pluginDir, { recursive: true, force: true })
+  }
+
+  return uninstall.status === 0 || hadMarketplaceRoot || hadLegacyPluginDir
+}
+
 export function planInstallPlugin(
   distDir: string,
   pluginName: string,
@@ -655,6 +796,9 @@ export async function installPlugin(
     } else {
       createSymlinkInstall(target)
     }
+    if (target.platform === 'codex') {
+      ensureCodexMarketplace(pluginName)
+    }
     if (!options.quiet) {
       console.log(`  ${target.platform} -> ${target.description}`)
     }
@@ -665,22 +809,37 @@ export async function installPlugin(
     console.log('Nothing to install. Run `pluxx build` first.')
   } else if (!options.quiet) {
     console.log(`\nInstalled ${installed} plugin(s). Reload or restart your tools to pick them up.`)
+    for (const note of getInstallFollowupNotes(filtered.map((target) => target.platform))) {
+      console.log(note)
+    }
   }
 }
 
 export async function uninstallPlugin(
   pluginName: string,
   platforms?: TargetPlatform[],
-  options: { quiet?: boolean } = {},
+  options: { quiet?: boolean; runCommand?: CommandRunner } = {},
 ): Promise<void> {
   const targets = getInstallTargets(pluginName)
   const filtered = platforms
     ? targets.filter(t => platforms.includes(t.platform))
     : targets
+  const runCommand = options.runCommand ?? runCommandDefault
 
   let removed = 0
 
   for (const target of filtered) {
+    if (target.platform === 'claude-code') {
+      const removedClaude = uninstallClaudePlugin(target, pluginName, runCommand, { quiet: options.quiet })
+      if (removedClaude) {
+        if (!options.quiet) {
+          console.log(`  removed ${target.description}`)
+        }
+        removed++
+      }
+      continue
+    }
+
     if (existsSync(target.pluginDir)) {
       rmSync(target.pluginDir, { recursive: true, force: true })
       if (!options.quiet) {
@@ -688,6 +847,9 @@ export async function uninstallPlugin(
       }
       removed++
     }
+    if (target.platform === 'codex') {
+      removeCodexMarketplacePlugin(pluginName)
+    }
   }
 
   if (removed === 0 && !options.quiet) {

package/src/cli/lint.ts

@@ -66,6 +66,10 @@ export interface LintResult {
   issues: LintIssue[]
 }
 
+export interface LintProjectOptions {
+  targets?: TargetPlatform[]
+}
+
 const SKILL_NAME_REGEX = AGENT_SKILLS_RULES.name.pattern
 const MAX_AGENT_SKILLS_DESCRIPTION = AGENT_SKILLS_RULES.description.maxLength
 const MAX_CLAUDE_DESCRIPTION = CLAUDE_CODE_RULES.description.maxDisplayLength
@@ -1035,6 +1039,25 @@ function lintCursorRuleContentLimits(config: PluginConfig, issues: LintIssue[]):
 function lintPermissions(config: PluginConfig, issues: LintIssue[]): void {
   if (!config.permissions) return
 
+  for (const action of ['allow', 'ask', 'deny'] as const) {
+    const seen = new Set<string>()
+    for (const raw of config.permissions[action] ?? []) {
+      const trimmed = raw.trim()
+
+      if (seen.has(trimmed)) {
+        pushIssue(issues, {
+          level: 'warning',
+          code: 'permissions-duplicate',
+          message: `Permission rule "${trimmed}" is duplicated in "${action}".`,
+          file: 'pluxx.config.ts',
+          platform: 'Permissions',
+        })
+      }
+
+      seen.add(trimmed)
+    }
+  }
+
   const rules = collectPermissionRules(config.permissions)
   const seen = new Map<string, Set<string>>()
 
@@ -1061,7 +1084,7 @@ function lintPermissions(config: PluginConfig, issues: LintIssue[]): void {
     pushIssue(issues, {
       level: 'warning',
       code: 'codex-permissions-external-config',
-      message: 'Codex does not currently support plugin-packaged permission enforcement. Mirror canonical permissions into Codex user/admin config or external hooks for real enforcement.',
+      message: 'Codex does not currently support plugin-packaged permission enforcement. Mirror canonical permissions into Codex user/admin config or external hooks for real enforcement (Pluxx emits .codex/permissions.generated.json as a starter mirror).',
       file: 'pluxx.config.ts',
       platform: 'Codex',
     })
@@ -1100,7 +1123,10 @@ function sortIssues(issues: LintIssue[]): LintIssue[] {
   })
 }
 
-export async function lintProject(dir: string = process.cwd()): Promise<LintResult> {
+export async function lintProject(
+  dir: string = process.cwd(),
+  options: LintProjectOptions = {},
+): Promise<LintResult> {
   const issues: LintIssue[] = []
   const frontmatterCache = new Map<string, ParsedFrontmatterFile>()
 
@@ -1118,17 +1144,21 @@ export async function lintProject(dir: string = process.cwd()): Promise<LintResu
     return { errors: 1, warnings: 0, issues }
   }
 
+  const lintConfig: PluginConfig = options.targets
+    ? { ...config, targets: options.targets }
+    : config
+
   // Plugin structure checks
-  lintPluginName(config, issues)
-  lintVersionFormat(config, issues)
-  lintManifestPaths(config, issues)
+  lintPluginName(lintConfig, issues)
+  lintVersionFormat(lintConfig, issues)
+  lintManifestPaths(lintConfig, issues)
   lintPluginDirectoryPlacement(dir, issues)
-  lintAbsolutePaths(config, issues)
+  lintAbsolutePaths(lintConfig, issues)
   lintSettingsJson(dir, issues)
-  lintLegacyCommandsDir(dir, config, issues)
+  lintLegacyCommandsDir(dir, lintConfig, issues)
 
   // Hook and event validation
-  lintHookEvents(config, issues)
+  lintHookEvents(lintConfig, issues)
 
   // Agent file checks
   const agentsDir = resolve(dir, 'agents')
@@ -1137,25 +1167,25 @@ export async function lintProject(dir: string = process.cwd()): Promise<LintResu
   lintAgentIsolation(agentFiles, issues, frontmatterCache)
 
   // MCP and brand
-  lintMcpUrls(config, issues)
-  lintBrandMetadata(config, issues)
-  lintCodexOverrides(config, issues)
-  lintCodexHookCompatibility(config, issues)
-  lintCodexAgentsConfig(config, issues)
-  lintCodexHooksExternalConfig(config, issues)
-  lintPermissions(config, issues)
+  lintMcpUrls(lintConfig, issues)
+  lintBrandMetadata(lintConfig, issues)
+  lintCodexOverrides(lintConfig, issues)
+  lintCodexHookCompatibility(lintConfig, issues)
+  lintCodexAgentsConfig(lintConfig, issues)
+  lintCodexHooksExternalConfig(lintConfig, issues)
+  lintPermissions(lintConfig, issues)
 
   // Cursor-specific checks
-  lintCursorHooks(config, issues)
-  lintCursorRuleContentLimits(config, issues)
+  lintCursorHooks(lintConfig, issues)
+  lintCursorRuleContentLimits(lintConfig, issues)
 
-  const skillsDir = resolve(dir, config.skills)
+  const skillsDir = resolve(dir, lintConfig.skills)
   let skillFiles: string[] = []
   if (!existsSync(skillsDir)) {
     pushIssue(issues, {
       level: 'error',
       code: 'skills-dir-missing',
-      message: `Skills directory not found: ${config.skills}`,
+      message: `Skills directory not found: ${lintConfig.skills}`,
       file: 'pluxx.config.ts',
       platform: 'Agent Skills',
     })
@@ -1165,29 +1195,29 @@ export async function lintProject(dir: string = process.cwd()): Promise<LintResu
       pushIssue(issues, {
         level: 'warning',
         code: 'skills-none-found',
-        message: `No SKILL.md files found in ${config.skills}`,
+        message: `No SKILL.md files found in ${lintConfig.skills}`,
         file: 'pluxx.config.ts',
         platform: 'Agent Skills',
       })
     }
 
     for (const skillFile of skillFiles) {
-      lintSkillFile(skillFile, config.targets, issues, frontmatterCache)
+      lintSkillFile(skillFile, lintConfig.targets, issues, frontmatterCache)
     }
   }
 
   // Cursor skill frontmatter checks
-  lintCursorSkillFrontmatter(config, skillFiles, issues, frontmatterCache)
-  lintSkillListingBudgets(skillFiles, config.targets, issues, frontmatterCache)
+  lintCursorSkillFrontmatter(lintConfig, skillFiles, issues, frontmatterCache)
+  lintSkillListingBudgets(skillFiles, lintConfig.targets, issues, frontmatterCache)
 
   // Platform limit checks for manifest prompts (Codex)
-  lintManifestPromptLimits(config, issues)
+  lintManifestPromptLimits(lintConfig, issues)
 
   // Platform limit checks for instructions file size
-  lintInstructionsFileLimits(config, dir, issues)
+  lintInstructionsFileLimits(lintConfig, dir, issues)
 
   // Platform limit checks for rules file line count
-  lintRulesFileLimits(config, dir, issues)
+  lintRulesFileLimits(lintConfig, dir, issues)
 
   const sorted = sortIssues(issues)
   const errors = sorted.filter(i => i.level === 'error').length