dazscript-framework 0.2.4 → 0.3.1

package/README.md

@@ -13,7 +13,9 @@ The **DazScript Framework** is a TypeScript-based framework for writing Daz Stud
 ## Features
 
 - TypeScript support with full IntelliSense.
-- A powerful set of decorators and helper methods for building interactive scripts.
+- A lightweight `action(...)` entrypoint plus helper methods for building interactive scripts.
+- A generated setup dialog for installing, updating, and removing custom action registrations.
+- Setup generation is fully automated from `action(...)` metadata, including menu path, toolbar, shortcut, description, grouping, icons, and bundle-based setup outputs.
 - Easy integration with Daz Studio for quick script deployment.
 
 ## Installation
@@ -32,6 +34,8 @@ After installing the package, scaffold the project files:
 npx dazscript init
 ```
 
+If `--app-data-path` is not provided, `init` prompts for the AppData author namespace up front and uses the current folder name as the default product segment.
+
 This generates:
 
 - `dazscript.config.ts`
@@ -43,15 +47,39 @@ The generated package scripts use the framework CLI directly, so consumer projec
 You can customize the generated defaults:
 
 ```bash
-npx dazscript init --menu-path /MyScripts --scripts-path ./src --out-dir ./out
+npx dazscript init --menu-path /MyScripts --scripts-path ./src --out-dir ./out --app-data-path YourName/my-project
 ```
 
 - `--menu-path` sets which Daz Studio menu the scripts are added to by default. See [The `action(...)` Entrypoint](#the-action-entrypoint) for how a script can override that with `menuPath`.
 - `--scripts-path` tells the installer generator where to scan for runnable `.dsa.ts` entry files.
 - `--out-dir` sets the webpack build output directory for generated `.dsa` files and copied icons.
+- `--app-data-path` sets the AppData namespace used by launcher fallback resolution. Use a unique `Author/Product` path.
 
 Use `--scripts-path ./src/scripts` for projects shaped like `scripts/common`, where runnable `.dsa.ts` files live under `src/scripts/`. Use `--scripts-path ./src` for packages shaped like `scripts/power-menu`, where runnable `.dsa.ts` files live at the source root.
 
+Set `appDataPath` explicitly in `dazscript.config.ts` for every project. It is required for builds that generate launcher shims:
+
+```typescript
+import { defineConfig } from 'dazscript-framework/config';
+
+export default defineConfig({
+  scriptsPath: './src',
+  outDir: './out',
+  defaultMenuPath: '/MyScripts',
+  appDataPath: 'YourName/my-project',
+  bundleName: 'My Project',
+});
+```
+
+`bundleName` is optional display metadata for generated setup dialogs. If omitted, the dialog falls back to `Setup Scripts`. `dazscript init` now scaffolds it automatically from the project folder name.
+
+Built action outputs now use stable launcher shims by default:
+
+- `out/<script>.dsa` is the stable launcher registered with Daz Studio menus, toolbars, and shortcuts
+- `out/<folder>/lib/<script-name>/script.dsa` is the current implementation bundle that the launcher executes
+
+Rebuilding updates the implementation bundle under the shim's sibling `lib/` folder. At runtime, each launcher checks that local `lib/` path first and falls back to `App.getAppDataPath()/...` second. Because the registered launcher path stays stable, action updates normally do not require reinstalling the action in Daz Studio.
+
 ## Usage
 
 ### Quick Start: Hello World
@@ -106,7 +134,67 @@ Common `action(...)` parameters:
 - `toolbar`: the toolbar name used when the action should appear on a toolbar.
 - `group`: an optional grouping label used by Daz Studio for related actions.
 - `description`: a longer description for the action.
-- `bundle`: generates installer and uninstaller entries as a package bundle instead of a single action entry.
+- `bundle`: generates an additional setup script next to the action file. Use `true` for `Setup.dsa.ts` or a string for `Setup <bundle>.dsa.ts`.
+
+When an action is built, the framework emits two files for it:
+
+- the stable launcher at the original output path
+- the implementation bundle under a sibling `lib/<script-name>/script.dsa` path
+
+Generated installers register the launcher path, so menu placement, toolbars, shortcuts, and icons keep pointing at a stable target across rebuilds.
+
+If the local `lib/` implementation is missing, the launcher falls back to the configured `appDataPath`. Builds now require this value and validate it as a unique `Author/Product` style path.
+
+### Generated Setup Script
+
+Running `npm run installer` generates `src/Setup.dsa.ts` for the project.
+
+This flow is completely automated. The installer generator scans runnable `.dsa.ts` entry files, reads the top-level `action(...)` call, and derives the setup dialog rows and registration behavior directly from that metadata. In practice, the menu path, toolbar target, shortcut, description, grouping, icon usage, and bundle-specific setup outputs all come from the action definition rather than from separate installer code you have to maintain by hand.
+
+The generated setup script:
+
+- Scans all runnable top-level `.dsa.ts` files under `scriptsPath`
+- Reads `action(...)` metadata directly from the source
+- Normalizes default menu paths relative to `defaultMenuPath`
+- Derives action labels, descriptions, shortcuts, toolbar targets, grouping, and icons from the action definition
+- Writes one searchable setup entry per discovered action
+- Uses `appDataPath/Installer` as the installer settings namespace
+- Passes `bundleName` through so the dialog title can be project-specific
+
+The setup dialog initializes from the current Daz Studio install state rather than assuming a clean install. It checks which actions are already installed, which ones are present in menus or toolbars, and what shortcut is currently assigned.
+
+Current setup dialog behavior:
+
+- Shows an install checkbox plus the columns `Action`, `Shortcut`, `Description`, `Menu`, and `Toolbar`
+- Includes a search box that filters by action name, shortcut, description, menu path, and toolbar
+- Supports `Select All` and `Deselect All` for the currently visible rows
+- Lets the user right-click an action to set a shortcut or reset it to the default shortcut
+- Shows shortcut overrides with an `[ovr]` marker
+- Displays the configured toolbar name directly instead of a generic yes/no flag
+- Uses the configured `bundleName` in the window title when available
+
+Applying the setup dialog does both install and cleanup work:
+
+- Selected rows are installed or updated through the framework custom action helpers
+- Unselected rows are removed from supported menu and toolbar targets
+- Affected toolbars are rebuilt after removal so remaining selected actions stay grouped correctly
+- Empty toolbars created by the framework are cleaned up automatically
+
+The generated project-level setup file replaces the older generated `Install.dsa.ts` and `Uninstall.dsa.ts` flow. The installer generator now removes those legacy files if they still exist.
+
+### Action-Level Bundles
+
+The `bundle` property on `action(...)` is separate from project `bundleName`.
+
+- `bundleName` in `dazscript.config.ts` is project metadata used for the setup dialog title
+- `bundle` in an action definition changes installer generation behavior for that action
+
+When `bundle` is set on an action, the installer generator also writes a setup script beside that action:
+
+- `bundle: true` writes `Setup.dsa.ts`
+- `bundle: 'Utilities'` writes `Setup Utilities.dsa.ts`
+
+Those bundle-generated setup files use the same setup dialog helper and now also receive the project `bundleName`.
 
 ### Building UIs with Observables & Dialogs
 
@@ -302,7 +390,7 @@ my-daz-scripts/
 │   │   ├── my-dialog.ts
 │   │   └── my-dialog-script.dsa.ts
 │   └── config.ts
-├── out/                    # Generated .dsa files (build output)
+├── out/                    # Generated launchers, implementations, and copied icons
 ├── package.json
 ├── tsconfig.json
 └── dazscript.config.ts
@@ -311,8 +399,10 @@ my-daz-scripts/
 **Key points:**
 - Scripts ending in `.dsa.ts` compile to `.dsa` files for Daz Studio
 - Regular `.ts` files are utility, model, or helper classes
+- Built action outputs are split into stable launchers plus sibling `lib/<script-name>/script.dsa` implementations
 - Run `npm run build` to compile TypeScript → Daz Scripts
 - Run `npm run watch` during development for live rebuild
+- Rebuild after script changes; reinstalling Daz actions is usually not required because the launcher path stays stable
 
 ## Development & Publishing
 

package/dist/scripts/app-data-path.js

@@ -0,0 +1,50 @@
+'use strict';
+
+function toPosix(filePath) {
+  return filePath.replace(/\\/g, '/');
+}
+
+function validateAppDataPath(appDataPath, workdir) {
+  if (!appDataPath || typeof appDataPath !== 'string') {
+    throw new Error(
+      `[dazscript] Missing required appDataPath in ${workdir}. ` +
+      `Set appDataPath: 'Author/Product' in dazscript.config.ts.`
+    );
+  }
+
+  const normalized = toPosix(appDataPath).trim().replace(/^\/+|\/+$/g, '');
+  const segments = normalized.split('/').filter(Boolean);
+
+  if (segments.length < 2) {
+    throw new Error(
+      `[dazscript] Invalid appDataPath "${appDataPath}" in ${workdir}. ` +
+      `Use at least two segments, for example 'Author/Product'.`
+    );
+  }
+
+  const blockedSegments = new Set([
+    'appdata',
+    'cache',
+    'data',
+    'lib',
+    'libs',
+    'script',
+    'scripts',
+    'temp',
+    'tmp',
+  ]);
+
+  const invalidSegment = segments.find((segment) => blockedSegments.has(segment.toLowerCase()));
+  if (invalidSegment) {
+    throw new Error(
+      `[dazscript] Invalid appDataPath "${appDataPath}" in ${workdir}. ` +
+      `Path segments like "${invalidSegment}" are too generic. Use a unique Author/Product path.`
+    );
+  }
+
+  return normalized;
+}
+
+module.exports = {
+  validateAppDataPath,
+};

package/dist/scripts/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 'use strict';
 
+const path = require('path');
+const readline = require('readline');
 const { runWebpack } = require('./build');
 const { loadConfig } = require('./config-loader');
 const { copyIcons } = require('./icons');
@@ -21,11 +23,58 @@ Options for init:
   --menu-path <path>    Default menu path. Default: /MyScripts
   --scripts-path <path> Source directory to scan. Default: ./src
   --out-dir <path>      Build output directory. Default: ./out
+  --app-data-path <path> AppData namespace used by launcher fallbacks. Example: Author/Product
   --force               Overwrite generated files
   --help                Show this message
 `);
 }
 
+function askQuestion(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer));
+  });
+}
+
+async function resolveInitOptions(workdir, options) {
+  if (options.appDataPath) {
+    return options;
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return options;
+  }
+
+  const defaultProductName = path.basename(workdir);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    let author = '';
+    while (!author) {
+      const answer = await askQuestion(
+        rl,
+        'AppData author namespace (for example Vholf3D): '
+      );
+      author = answer.trim();
+    }
+
+    const productAnswer = await askQuestion(
+      rl,
+      `AppData product namespace [${defaultProductName}]: `
+    );
+    const product = productAnswer.trim() || defaultProductName;
+
+    return {
+      ...options,
+      appDataPath: `${author}/${product}`,
+    };
+  } finally {
+    rl.close();
+  }
+}
+
 function parseOptions(args, defaults) {
   const options = { ...defaults };
 
@@ -55,6 +104,12 @@ function parseOptions(args, defaults) {
       continue;
     }
 
+    if (arg === '--app-data-path') {
+      options.appDataPath = args[index + 1];
+      index += 1;
+      continue;
+    }
+
     if (arg === '--file') {
       options.file = args[index + 1];
       index += 1;
@@ -101,6 +156,7 @@ async function main(argv) {
     menuPath: undefined,
     scriptsPath: undefined,
     outDir: undefined,
+    appDataPath: undefined,
     file: undefined,
   });
 
@@ -109,7 +165,14 @@ async function main(argv) {
     return;
   }
 
+  const commandOptions =
+    command === 'init'
+      ? await resolveInitOptions(workdir, options)
+      : options;
   const resolvedOptions = getResolvedOptions(workdir, options);
+  if (commandOptions !== options) {
+    Object.assign(resolvedOptions, commandOptions);
+  }
   resolvedOptions.menuPath = resolvedOptions.menuPath || '/MyScripts';
   resolvedOptions.scriptsPath = resolvedOptions.scriptsPath || './src';
   resolvedOptions.outDir = resolvedOptions.outDir || './out';

package/dist/scripts/init.js

@@ -49,10 +49,20 @@ export default defineConfig({
   scriptsPath: '${options.scriptsPath}',
   outDir: '${options.outDir}',
   defaultMenuPath: '${options.menuPath}',
+  appDataPath: '${options.appDataPath}',
+  bundleName: '${options.bundleName}',
 });
 `;
 }
 
+function toBundleName(projectName) {
+  return projectName
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+}
+
 function buildTsconfigContent() {
   return `{
   "extends": "./node_modules/dazscript-framework/tsconfig.json",
@@ -94,11 +104,14 @@ function updatePackageJson(workdir, options) {
 }
 
 function initProject(workdir, rawOptions) {
+  const projectName = path.basename(workdir);
   const options = {
     force: Boolean(rawOptions.force),
     menuPath: normalizePath(rawOptions.menuPath, '/MyScripts'),
     scriptsPath: normalizePath(rawOptions.scriptsPath, './src'),
     outDir: normalizePath(rawOptions.outDir, './out'),
+    appDataPath: normalizePath(rawOptions.appDataPath, `YourName/${projectName}`),
+    bundleName: toBundleName(projectName),
   };
 
   writeFileIfNeeded(

package/dist/scripts/install-generator.js

@@ -2,6 +2,8 @@ const ts = require('typescript');
 const fs = require('fs');
 const path = require('path');
 const glob = require('glob');
+const { loadConfig } = require('./config-loader');
+const { validateAppDataPath } = require('./app-data-path');
 
 const nameofActionFunction = 'action';
 
@@ -19,19 +21,14 @@ function stringOrDefault(str, defaultValue) {
   return str !== undefined && str !== null && str !== '' ? str : defaultValue;
 }
 
-function generateInstallerTemplate(data) {
+function generateInstallerTemplate(data, settingsPath, bundleName) {
   return `
-import { installCustomActions as install } from '@dsf/helpers/custom-action-helper';
+import { showSetupCustomActionsDialog as setup } from '@dsf/helpers/custom-action-installer-helper';
 
-install(${data});
-`;
-}
-
-function generateUninstallerTemplate(data) {
-  return `
-import { uninstallCustomActions as uninstall } from '@dsf/helpers/custom-action-helper';
-
-uninstall(${data});
+setup(${data}, ${JSON.stringify({
+    settingsPath,
+    bundleName,
+  })});
 `;
 }
 
@@ -141,7 +138,20 @@ function findTopLevelActionCall(content, filePath) {
   return null;
 }
 
-function processScript(filePath, container, defaultMenuPath) {
+function findActionEntryFiles(workdir, options) {
+  const scriptsPath = options.scriptsPath.endsWith('/')
+    ? options.scriptsPath
+    : `${options.scriptsPath}/`;
+  const matches = glob.sync(`${scriptsPath}/**/*.dsa.ts`, { cwd: workdir });
+
+  return matches.filter((filePath) => {
+    const absolutePath = path.join(workdir, filePath);
+    const content = fs.readFileSync(absolutePath, 'utf-8').toString();
+    return !!findTopLevelActionCall(content, absolutePath);
+  });
+}
+
+function processScript(filePath, container, defaultMenuPath, settingsPath, bundleName) {
   const fileInfo = path.parse(filePath);
   const content = fs.readFileSync(filePath, 'utf-8').toString();
   const actionCall = findTopLevelActionCall(content, filePath);
@@ -195,52 +205,46 @@ function processScript(filePath, container, defaultMenuPath) {
   container.scripts.push(script);
 
   if (decorator.bundle !== undefined) {
-    let packageInstallerFilePath = `Install.dsa.ts`;
-    let packageUninstallerFilePath = `Uninstall.dsa.ts`;
+    let packageSetupFilePath = `Setup.dsa.ts`;
 
     if (decorator.bundle !== true) {
-      packageInstallerFilePath = `Install ${decorator.bundle}.dsa.ts`;
-      packageUninstallerFilePath = `Uninstall ${decorator.bundle}.dsa.ts`;
+      packageSetupFilePath = `Setup ${decorator.bundle}.dsa.ts`;
     }
 
     let bundleScriptContent = generateInstallerTemplate(
-      JSON.stringify(container.scripts, null, 4)
+      JSON.stringify(container.scripts, null, 4),
+      settingsPath,
+      bundleName
     );
     let bundleScriptFilePath = path.join(
       path.parse(filePath).dir,
-      packageInstallerFilePath
-    );
-    fs.writeFileSync(bundleScriptFilePath, bundleScriptContent);
-
-    bundleScriptContent = generateUninstallerTemplate(
-      JSON.stringify(container.scripts, null, 4)
-    );
-    bundleScriptFilePath = path.join(
-      path.parse(filePath).dir,
-      packageUninstallerFilePath
+      packageSetupFilePath
     );
     fs.writeFileSync(bundleScriptFilePath, bundleScriptContent);
   }
 }
 
-function processScripts(paths, container, defaultMenuPath) {
+function processScripts(paths, container, defaultMenuPath, settingsPath, bundleName) {
   paths.forEach((filePath) => {
     console.log(`Processing ${filePath}`);
-    processScript(filePath, container, defaultMenuPath);
+    processScript(filePath, container, defaultMenuPath, settingsPath, bundleName);
   });
 }
 
 function generateInstallerFiles(workdir, options) {
-  const scriptsPath = options.scriptsPath.endsWith('/')
-    ? options.scriptsPath
-    : `${options.scriptsPath}/`;
   const defaultMenuPath = options.defaultMenuPath.endsWith('/')
     ? options.defaultMenuPath
     : `${options.defaultMenuPath}/`;
+  const { config } = loadConfig(workdir);
+  const appDataPath = validateAppDataPath(options.appDataPath || config.appDataPath, workdir);
+  const settingsPath = `${appDataPath}/Installer`;
+  const bundleName = typeof config.bundleName === 'string' && config.bundleName.trim()
+    ? config.bundleName.trim()
+    : undefined;
   const container = { scripts: [] };
-  const matches = glob.sync(`${scriptsPath}/**/*.dsa.ts`, { cwd: workdir });
+  const matches = findActionEntryFiles(workdir, options);
 
-  processScripts(matches, container, defaultMenuPath);
+  processScripts(matches, container, defaultMenuPath, settingsPath, bundleName);
 
   container.scripts = container.scripts.sort((a, b) => {
     const aKey = a.menuPath + a.filePath;
@@ -249,17 +253,16 @@ function generateInstallerFiles(workdir, options) {
   });
 
   const installerScriptContent = generateInstallerTemplate(
-    JSON.stringify(container.scripts, null, 4)
+    JSON.stringify(container.scripts, null, 4),
+    settingsPath,
+    bundleName
   );
-  fs.writeFileSync(path.join(workdir, 'src', 'Install.dsa.ts'), installerScriptContent);
+  fs.writeFileSync(path.join(workdir, 'src', 'Setup.dsa.ts'), installerScriptContent);
 
-  const uninstallerScriptContent = generateUninstallerTemplate(
-    JSON.stringify(container.scripts, null, 4)
-  );
-  fs.writeFileSync(
-    path.join(workdir, 'src', 'Uninstall.dsa.ts'),
-    uninstallerScriptContent
-  );
+  const installPath = path.join(workdir, 'src', 'Install.dsa.ts');
+  const uninstallPath = path.join(workdir, 'src', 'Uninstall.dsa.ts');
+  if (fs.existsSync(installPath)) fs.unlinkSync(installPath);
+  if (fs.existsSync(uninstallPath)) fs.unlinkSync(uninstallPath);
 }
 
 if (require.main === module) {
@@ -267,6 +270,7 @@ if (require.main === module) {
   const options = {
     scriptsPath: './src',
     defaultMenuPath: 'My Scripts',
+    appDataPath: undefined,
   };
 
   for (let index = 0; index < args.length; index += 1) {
@@ -284,6 +288,12 @@ if (require.main === module) {
       continue;
     }
 
+    if (arg === '--app-data-path') {
+      options.appDataPath = args[index + 1];
+      index += 1;
+      continue;
+    }
+
     throw new Error(`Unknown option: ${arg}`);
   }
 
@@ -292,4 +302,5 @@ if (require.main === module) {
 
 module.exports = {
   generateInstallerFiles,
+  findActionEntryFiles,
 };

package/dist/scripts/launchers.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { findActionEntryFiles } = require('./install-generator');
+const { validateAppDataPath } = require('./app-data-path');
+
+function toPosix(filePath) {
+  return filePath.replace(/\\/g, '/');
+}
+
+function getActionOutputPath(workdir, outDir, sourceFile) {
+  const sourceRoot = path.resolve(workdir, 'src');
+  const absoluteSourceFile = path.resolve(workdir, sourceFile);
+  const relativeSourceFile = toPosix(path.relative(sourceRoot, absoluteSourceFile));
+  return relativeSourceFile.replace(/\.ts$/, '');
+}
+
+function getImplementationRelativePath(outputRelativePath) {
+  const outputDirectory = path.posix.dirname(outputRelativePath);
+  const outputBaseName = path.posix.basename(outputRelativePath, '.dsa');
+  const implementationDirectory = outputDirectory === '.'
+    ? path.posix.join('lib', outputBaseName)
+    : path.posix.join(outputDirectory, 'lib', outputBaseName);
+
+  return path.posix.join(implementationDirectory, 'script.dsa');
+}
+
+function makeLauncherSource(implementationRelativePath, appDataImplementationRelativePath) {
+  return [
+    '// Auto-generated launcher shim.',
+    '// The installed Daz action points at this stable file.',
+    '// The current implementation is resolved from the sibling lib/ directory first,',
+    '// and from the AppData fallback location second.',
+    '',
+    `var implementationRelativePath = '${implementationRelativePath}';`,
+    `var appDataImplementationRelativePath = '${appDataImplementationRelativePath}';`,
+    'var launcherFileName = getScriptFileName();',
+    'var launcherInfo = new DzFileInfo(launcherFileName);',
+    'var launcherDirectory = typeof launcherInfo.canonicalPath == "function"',
+    '    ? launcherInfo.canonicalPath()',
+    '    : launcherInfo.path();',
+    'launcherInfo.deleteLater();',
+    '',
+    "var implementationPath = launcherDirectory + '/' + implementationRelativePath;",
+    'var implementationFile = new DzFile(implementationPath);',
+    'if (!implementationFile.exists()) {',
+    '    implementationFile.deleteLater();',
+    "    implementationPath = App.getAppDataPath() + '/' + appDataImplementationRelativePath;",
+    '    implementationFile = new DzFile(implementationPath);',
+    '}',
+    '',
+    'if (!implementationFile.exists()) {',
+    `    MessageBox.warning('Unable to find script implementation:\\n' + implementationPath, 'Missing Script', '&OK;', '');`,
+    '    implementationFile.deleteLater();',
+    '} else {',
+    '    implementationFile.deleteLater();',
+    '',
+    '    var script = new DzScript(implementationPath);',
+    '    if (!script.loadFromFile(implementationPath, true)) {',
+    `        MessageBox.warning('Unable to load script implementation:\\n' + implementationPath, 'Script Load Error', '&OK;', '');`,
+    '        script.deleteLater();',
+    '    } else {',
+    "        var args = typeof getArguments == 'function' ? getArguments() : [];",
+    '        script.execute(args);',
+    '        script.deleteLater();',
+    '    }',
+    '}',
+    '',
+  ].join('\n');
+}
+
+function ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function createActionLaunchers(workdir, options) {
+  const outDir = path.resolve(workdir, options.outDir || './out');
+  const appDataPath = validateAppDataPath(options.appDataPath, workdir);
+  const actionEntryFiles = findActionEntryFiles(workdir, {
+    scriptsPath: options.scriptsPath || './src',
+  });
+
+  actionEntryFiles.forEach((sourceFile) => {
+    const outputRelativePath = getActionOutputPath(workdir, outDir, sourceFile);
+    const launcherPath = path.join(outDir, outputRelativePath);
+    const implementationRelativePath = getImplementationRelativePath(outputRelativePath);
+    const implementationPath = path.join(outDir, implementationRelativePath);
+
+    if (!fs.existsSync(launcherPath)) {
+      return;
+    }
+
+    ensureParentDir(implementationPath);
+    if (fs.existsSync(implementationPath)) {
+      fs.unlinkSync(implementationPath);
+    }
+
+    fs.renameSync(launcherPath, implementationPath);
+
+    const launcherDir = path.dirname(outputRelativePath);
+    const relativeImplementationPath = toPosix(
+      path.relative(launcherDir || '.', implementationRelativePath)
+    );
+    const appDataImplementationRelativePath = toPosix(
+      path.posix.join(appDataPath, implementationRelativePath)
+    );
+
+    fs.writeFileSync(
+      launcherPath,
+      makeLauncherSource(
+        relativeImplementationPath,
+        appDataImplementationRelativePath
+      )
+    );
+  });
+}
+
+module.exports = {
+  createActionLaunchers,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dazscript-framework",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "author": "Freddy Diaz",
   "license": "MPL-2.0",
   "description": "",
@@ -67,6 +67,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.10.5",
+    "dazscript-types": "^0.2.4",
     "eslint": "^9.17.0",
     "typescript": "^5.7.3"
   }

package/src/{Install.dsa.ts → Setup.dsa.ts}

@@ -1,7 +1,7 @@
 
-import { installCustomActions as install } from '@dsf/helpers/custom-action-helper';
+import { showSetupCustomActionsDialog as setup } from '@dsf/helpers/custom-action-installer-helper';
 
-install([
+setup([
     {
         "name": null,
         "text": "Hello World",
@@ -16,4 +16,4 @@ install([
         "menuPath": "/DazScriptFramework/samples",
         "description": "sample-dialog"
     }
-]);
+], {"settingsPath":"DazScriptFramework/samples/Installer","bundleName":"Samples"});