hyper-animator-codex 0.7.0 → 0.7.1

package/README.md

@@ -22,19 +22,31 @@ Or install the CLI globally:
 
 ```bash
 npm install -g hyper-animator-codex
-hyper-animator-codex install --force
 ```
 
-By default the installer copies the skill to:
+Global install runs a postinstall step that copies the skill to both Codex and Claude Code:
 
 ```text
 ${CODEX_HOME:-$HOME/.codex}/skills/hyper-animator-codex
+${CLAUDE_HOME:-$HOME/.claude}/skills/hyper-animator-codex
+```
+
+To skip automatic skill installation during npm install:
+
+```bash
+HYPER_ANIMATOR_CODEX_SKIP_POSTINSTALL=1 npm install -g hyper-animator-codex
+```
+
+You can also run or re-run installation manually:
+
+```bash
+hyper-animator-codex install --force
 ```
 
-Use a custom Codex skills directory:
+Use one custom skills directory:
 
 ```bash
-npx hyper-animator-codex install --target /path/to/codex/skills
+npx hyper-animator-codex install --target /path/to/skills
 ```
 
 ## Git Checkpoints

package/bin/hyper-animator-codex.mjs

@@ -1,21 +1,29 @@
 #!/usr/bin/env node
-import { installSkill, resolveCodexSkillsRoot, SKILL_NAME } from "../lib/install-skill.mjs";
+import {
+  installSkillToTargets,
+  resolveClaudeCodeSkillsRoot,
+  resolveCodexSkillsRoot,
+  SKILL_NAME,
+} from "../lib/install-skill.mjs";
 import { parseInstallArgs } from "../lib/install-options.mjs";
 
 function printHelp() {
   console.log(`Usage:
   hyper-animator-codex install [--force] [--target <skills-dir>] [MiniMax options]
   hyper-animator-codex path
+  hyper-animator-codex paths
   hyper-animator-codex help
 
 Commands:
-  install  Install the packaged ${SKILL_NAME} skill into Codex
+  install  Install the packaged ${SKILL_NAME} skill into Codex and Claude Code
   path     Print the default Codex skills directory
+  paths    Print default Codex and Claude Code skills directories
   help     Show this help
 
 Options:
   --force                         Replace an existing installed skill
-  --target <dir>                  Install into a specific Codex skills directory
+  --quiet                         Suppress successful install output
+  --target <dir>                  Install into one specific skills directory
   --minimax-api-key <key>         Save MiniMax API key into installed skill config
   --minimax-group-id <group_id>   Save MiniMax group_id into installed skill config
   --minimax-model <model>         MiniMax text music model: music-2.6 or music-2.6-free
@@ -39,20 +47,34 @@ async function main() {
     return;
   }
 
+  if (command === "paths") {
+    console.log(`Codex: ${resolveCodexSkillsRoot()}`);
+    console.log(`Claude Code: ${resolveClaudeCodeSkillsRoot()}`);
+    return;
+  }
+
   if (command !== "install") {
     throw new Error(`Unknown command: ${command}`);
   }
 
   const options = parseInstallArgs(args);
-  const result = await installSkill(options);
+  const result = await installSkillToTargets(options);
+
+  if (options.quiet) {
+    return;
+  }
 
   console.log(`Installed ${result.skillName}`);
   console.log(`Source: ${result.sourcePath}`);
-  console.log(`Target: ${result.installedPath}`);
 
-  if (result.minimaxConfigPath) {
-    console.log(`MiniMax config: ${result.minimaxConfigPath}`);
-    console.log(`MiniMax model: ${result.minimaxConfig.model}`);
+  for (const install of result.installs) {
+    console.log(`${install.tool}: ${install.installedPath}`);
+    if (install.minimaxConfigPath) {
+      console.log(`${install.tool} MiniMax config: ${install.minimaxConfigPath}`);
+      if (install.minimaxConfig) {
+        console.log(`${install.tool} MiniMax model: ${install.minimaxConfig.model}`);
+      }
+    }
   }
 }
 

package/bin/postinstall.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { installSkillToTargets } from "../lib/install-skill.mjs";
+
+if (process.env.HYPER_ANIMATOR_CODEX_SKIP_POSTINSTALL === "1") {
+  process.exit(0);
+}
+
+try {
+  const result = await installSkillToTargets({
+    force: true,
+    quiet: true,
+    env: process.env,
+  });
+
+  const targets = result.installs.map((install) => `${install.tool}:${install.installedPath}`).join(", ");
+  console.log(`hyper-animator-codex installed skills: ${targets}`);
+} catch (error) {
+  console.warn(`hyper-animator-codex postinstall skipped: ${error.message}`);
+}

package/lib/install-options.mjs

@@ -11,6 +11,7 @@ function requireValue(args, index, flag) {
 export function parseInstallArgs(args) {
   const parsed = {
     force: false,
+    quiet: false,
     targetRoot: undefined,
     minimaxConfig: {},
   };
@@ -20,6 +21,8 @@ export function parseInstallArgs(args) {
 
     if (arg === "--force") {
       parsed.force = true;
+    } else if (arg === "--quiet") {
+      parsed.quiet = true;
     } else if (arg === "--target") {
       parsed.targetRoot = requireValue(args, index, arg);
       index += 1;

package/lib/install-skill.mjs

@@ -1,9 +1,10 @@
-import { cp, mkdir, rm, stat } from "node:fs/promises";
+import { chmod, cp, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import {
+  MINIMAX_CONFIG_RELATIVE_PATH,
   redactMinimaxConfig,
   resolveInstallMinimaxConfig,
   writeMinimaxConfig,
@@ -43,6 +44,44 @@ export function resolveCodexSkillsRoot(env = process.env) {
   return join(home, ".codex", "skills");
 }
 
+export function resolveClaudeCodeSkillsRoot(env = process.env) {
+  if (env.CLAUDE_HOME) {
+    return join(env.CLAUDE_HOME, "skills");
+  }
+
+  const home = env.HOME || homedir();
+  if (!home) {
+    throw new Error("Cannot resolve Claude Code skills directory: HOME is not set");
+  }
+
+  return join(home, ".claude", "skills");
+}
+
+async function readExistingMinimaxConfig(installedPath) {
+  const configPath = join(installedPath, MINIMAX_CONFIG_RELATIVE_PATH);
+
+  if (!(await pathExists(configPath))) {
+    return null;
+  }
+
+  return {
+    configPath,
+    body: await readFile(configPath, "utf8"),
+  };
+}
+
+async function restoreExistingMinimaxConfig(installedPath, existingConfig) {
+  if (!existingConfig) {
+    return null;
+  }
+
+  const configPath = join(installedPath, MINIMAX_CONFIG_RELATIVE_PATH);
+  await mkdir(dirname(configPath), { recursive: true });
+  await writeFile(configPath, existingConfig.body, { encoding: "utf8", mode: 0o600 });
+  await chmod(configPath, 0o600);
+  return configPath;
+}
+
 export async function installSkill(options = {}) {
   const targetRoot = options.targetRoot || resolveCodexSkillsRoot(options.env);
   const sourcePath = options.sourcePath || join(packageRoot, "skills", SKILL_NAME);
@@ -55,6 +94,8 @@ export async function installSkill(options = {}) {
 
   await mkdir(targetRoot, { recursive: true });
 
+  const existingMinimaxConfig = force ? await readExistingMinimaxConfig(installedPath) : null;
+
   if (await pathExists(installedPath)) {
     if (!force) {
       throw new Error(`${SKILL_NAME} already exists at ${installedPath}; rerun with --force to replace it`);
@@ -74,12 +115,53 @@ export async function installSkill(options = {}) {
   const minimaxWrite = resolvedMinimaxConfig
     ? await writeMinimaxConfig(installedPath, resolvedMinimaxConfig)
     : null;
+  const restoredMinimaxConfigPath = minimaxWrite ? null : await restoreExistingMinimaxConfig(installedPath, existingMinimaxConfig);
 
   return {
     skillName: SKILL_NAME,
+    tool: options.tool || "codex",
     sourcePath,
     installedPath,
-    minimaxConfigPath: minimaxWrite ? minimaxWrite.configPath : null,
+    minimaxConfigPath: minimaxWrite ? minimaxWrite.configPath : restoredMinimaxConfigPath,
     minimaxConfig: minimaxWrite ? redactMinimaxConfig(minimaxWrite.config) : null,
   };
 }
+
+export async function installSkillToTargets(options = {}) {
+  const sourcePath = options.sourcePath || join(packageRoot, "skills", SKILL_NAME);
+
+  if (options.targetRoot) {
+    const install = await installSkill({
+      ...options,
+      sourcePath,
+      tool: "custom",
+    });
+    return {
+      skillName: SKILL_NAME,
+      sourcePath,
+      installs: [install],
+    };
+  }
+
+  const env = options.env || process.env;
+  const installs = [];
+
+  for (const target of [
+    { tool: "codex", targetRoot: resolveCodexSkillsRoot(env) },
+    { tool: "claude-code", targetRoot: resolveClaudeCodeSkillsRoot(env) },
+  ]) {
+    installs.push(await installSkill({
+      ...options,
+      env,
+      sourcePath,
+      targetRoot: target.targetRoot,
+      tool: target.tool,
+    }));
+  }
+
+  return {
+    skillName: SKILL_NAME,
+    sourcePath,
+    installs,
+  };
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "hyper-animator-codex",
-  "version": "0.7.0",
-  "description": "Install the Hyper Animator Codex skill for Codex.",
+  "version": "0.7.1",
+  "description": "Install the Hyper Animator skill for Codex and Claude Code.",
   "type": "module",
   "bin": {
     "hyper-animator-codex": "bin/hyper-animator-codex.mjs"
   },
   "scripts": {
+    "postinstall": "node bin/postinstall.mjs",
     "test": "node --test",
     "pack:check": "npm pack --dry-run"
   },