@git.zone/cli 2.19.8 → 2.21.0

package/ts/mod_format/classes.baseformatter.ts

@@ -62,7 +62,31 @@ export abstract class BaseFormatter {
     // Override in subclasses if needed
   }
 
-  protected async modifyFile(filepath: string, content: string): Promise<void> {
+  protected normalizeFileMode(mode: string | undefined): string | undefined {
+    if (!mode) return undefined;
+    const normalizedMode = mode.trim();
+    if (!/^[0-7]{3,4}$/.test(normalizedMode)) {
+      throw new Error(`Invalid file mode ${mode}`);
+    }
+    return normalizedMode.padStart(4, '0');
+  }
+
+  protected async getFileMode(filepath: string): Promise<string | undefined> {
+    try {
+      const stats = await plugins.fs.stat(filepath);
+      return (stats.mode & 0o777).toString(8).padStart(4, '0');
+    } catch {
+      return undefined;
+    }
+  }
+
+  protected async setFileMode(filepath: string, mode: string): Promise<void> {
+    const normalizedMode = this.normalizeFileMode(mode);
+    if (!normalizedMode) return;
+    await plugins.fs.chmod(filepath, Number.parseInt(normalizedMode, 8));
+  }
+
+  protected async modifyFile(filepath: string, content: string, mode?: string): Promise<void> {
     if (!filepath || filepath.trim() === '') {
       throw new Error(`Invalid empty filepath in modifyFile`);
     }
@@ -73,9 +97,12 @@ export abstract class BaseFormatter {
     }
 
     await plugins.smartfs.file(normalizedPath).encoding('utf8').write(content);
+    if (mode) {
+      await this.setFileMode(normalizedPath, mode);
+    }
   }
 
-  protected async createFile(filepath: string, content: string): Promise<void> {
+  protected async createFile(filepath: string, content: string, mode?: string): Promise<void> {
     let normalizedPath = filepath;
     if (!plugins.path.parse(filepath).dir) {
       normalizedPath = './' + filepath;
@@ -88,6 +115,9 @@ export abstract class BaseFormatter {
     }
 
     await plugins.smartfs.file(normalizedPath).encoding('utf8').write(content);
+    if (mode) {
+      await this.setFileMode(normalizedPath, mode);
+    }
   }
 
   protected async deleteFile(filepath: string): Promise<void> {
@@ -115,13 +145,19 @@ export abstract class BaseFormatter {
         }
 
         const newContent = change.content;
+        const modeAfter = this.normalizeFileMode(change.mode);
+        const modeBefore = modeAfter ? await this.getFileMode(change.path) : undefined;
+        const hasContentDiff = currentContent !== newContent && newContent !== undefined;
+        const hasModeDiff = modeAfter !== undefined && modeBefore !== modeAfter;
 
-        if (currentContent !== newContent && newContent !== undefined) {
+        if (hasContentDiff || hasModeDiff) {
           diffs.push({
             path: change.path,
             type: change.type,
             before: currentContent,
             after: newContent,
+            modeBefore,
+            modeAfter,
           });
         }
       } else if (change.type === 'delete') {
@@ -147,21 +183,26 @@ export abstract class BaseFormatter {
 
   displayDiff(diff: ICheckResult['diffs'][0]): void {
     console.log(`\n--- ${diff.path}`);
-    if (diff.before && diff.after) {
+    if (diff.before !== undefined && diff.after !== undefined) {
       console.log(plugins.smartdiff.formatUnifiedDiffForConsole(diff.before, diff.after, {
         originalFileName: diff.path,
         revisedFileName: diff.path,
         context: 3,
       }));
-    } else if (diff.after && !diff.before) {
+    } else if (diff.after !== undefined && diff.before === undefined) {
       console.log('  (new file)');
       const lines = diff.after.split('\n').slice(0, 10);
       lines.forEach(line => console.log(`  + ${line}`));
       if (diff.after.split('\n').length > 10) {
         console.log('  ... (truncated)');
       }
-    } else if (diff.before && !diff.after) {
+    } else if (diff.type === 'delete') {
       console.log('  (file will be deleted)');
+    } else if (diff.modeAfter) {
+      console.log('  (file content unchanged)');
+    }
+    if (diff.modeBefore !== diff.modeAfter && diff.modeAfter) {
+      console.log(`  mode: ${diff.modeBefore || '(missing)'} -> ${diff.modeAfter}`);
     }
   }
 

package/ts/mod_format/formatters/assets.formatter.ts

@@ -0,0 +1,451 @@
+import { BaseFormatter } from '../classes.baseformatter.js';
+import type { IFormatWarning, IPlannedChange } from '../interfaces.format.js';
+import * as plugins from '../mod.plugins.js';
+import * as paths from '../../paths.js';
+import { logger, logVerbose } from '../../gitzone.logging.js';
+import { getCliConfigValue, readSmartconfigFile } from '../../helpers.smartconfig.js';
+
+interface IAssetFileMapping {
+  from: string;
+  to: string;
+  mode?: string;
+}
+
+interface IAssetTemplateEntry {
+  template: string;
+  files: IAssetFileMapping[];
+  enabled?: boolean;
+  variables?: Record<string, any>;
+}
+
+interface IBinaryTargetRenderData {
+  name: string;
+  assetName: string;
+  os: string;
+  arch: string;
+  denoTarget: string;
+  nodeKey: string;
+  label: string;
+}
+
+const isPlainObject = (value: unknown): value is Record<string, any> => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+
+const readJsonFile = async (filePath: string): Promise<Record<string, any>> => {
+  if (!(await plugins.smartfs.file(filePath).exists())) {
+    return {};
+  }
+  const content = (await plugins.smartfs.file(filePath).encoding('utf8').read()) as string;
+  return JSON.parse(content);
+};
+
+const uniqueStringArray = (value: unknown, fallback: string[] = []): string[] => {
+  if (!Array.isArray(value)) {
+    return fallback;
+  }
+  const result: string[] = [];
+  for (const item of value) {
+    if (typeof item !== 'string' || !item.trim()) {
+      continue;
+    }
+    if (!result.includes(item)) {
+      result.push(item);
+    }
+  }
+  return result;
+};
+
+const normalizeRepository = (assetsConfig: Record<string, any>, moduleConfig: Record<string, any>) => {
+  const repository = isPlainObject(assetsConfig.repository) ? assetsConfig.repository : {};
+  const host = repository.host || moduleConfig.githost || 'code.foss.global';
+  const path = repository.path || [moduleConfig.gitscope, moduleConfig.gitrepo].filter(Boolean).join('/');
+  const branch = repository.branch || repository.rawBranch || assetsConfig.rawBranch || 'main';
+  const baseUrl = `https://${host}/${path}`;
+  return {
+    host,
+    path,
+    branch,
+    baseUrl,
+    apiBaseUrl: `https://${host}/api/v1/repos/${path}`,
+    gitUrl: `${baseUrl}.git`,
+  };
+};
+
+const normalizeOs = (target: Record<string, any>): string => {
+  const rawValue = `${target.os || ''} ${target.target || ''} ${target.name || ''}`.toLowerCase();
+  if (rawValue.includes('apple') || rawValue.includes('darwin') || rawValue.includes('macos')) return 'macos';
+  if (rawValue.includes('windows') || rawValue.includes('pc-windows') || rawValue.includes('-win')) return 'windows';
+  return 'linux';
+};
+
+const normalizeArch = (target: Record<string, any>): string => {
+  const rawValue = `${target.arch || ''} ${target.target || ''} ${target.name || ''}`.toLowerCase();
+  if (rawValue.includes('aarch64') || rawValue.includes('arm64')) return 'arm64';
+  return 'x64';
+};
+
+const getNodePlatform = (os: string): string => {
+  if (os === 'macos') return 'darwin';
+  if (os === 'windows') return 'win32';
+  return 'linux';
+};
+
+const getPlatformLabel = (target: IBinaryTargetRenderData): string => {
+  const osLabel = target.os === 'macos' ? 'macOS' : target.os === 'windows' ? 'Windows' : 'Linux';
+  const archLabel = target.arch === 'arm64' ? 'ARM64' : 'x64';
+  return `${osLabel} ${archLabel}`;
+};
+
+const normalizeBinaryTargets = (
+  assetsConfig: Record<string, any>,
+  smartconfigData: Record<string, any>,
+): IBinaryTargetRenderData[] => {
+  const binaryConfig = isPlainObject(assetsConfig.binary) ? assetsConfig.binary : {};
+  const tsdenoConfig = smartconfigData['@git.zone/tsdeno'];
+  const targets = Array.isArray(binaryConfig.targets)
+    ? binaryConfig.targets
+    : isPlainObject(tsdenoConfig) && Array.isArray(tsdenoConfig.compileTargets)
+      ? tsdenoConfig.compileTargets
+      : [];
+
+  return targets
+    .filter((target) => isPlainObject(target) && typeof target.name === 'string')
+    .map((target) => {
+      const os = normalizeOs(target);
+      const arch = normalizeArch(target);
+      const isWindows = os === 'windows';
+      const assetName = isWindows && !target.name.endsWith('.exe') ? `${target.name}.exe` : target.name;
+      const result: IBinaryTargetRenderData = {
+        name: target.name,
+        assetName,
+        os,
+        arch,
+        denoTarget: target.target || target.denoTarget || '',
+        nodeKey: `${getNodePlatform(os)}:${arch}`,
+        label: '',
+      };
+      result.label = getPlatformLabel(result);
+      return result;
+    });
+};
+
+const buildDefaultEntries = (assetsConfig: Record<string, any>, cliName: string): IAssetTemplateEntry[] => {
+  if (assetsConfig.kind !== 'denoBinaryCli') {
+    return [];
+  }
+
+  const entries: IAssetTemplateEntry[] = [];
+  const installerConfig = isPlainObject(assetsConfig.installer) ? assetsConfig.installer : {};
+  const npmWrapperConfig = isPlainObject(assetsConfig.npmWrapper) ? assetsConfig.npmWrapper : {};
+  const releaseWorkflowConfig = isPlainObject(assetsConfig.releaseWorkflow)
+    ? assetsConfig.releaseWorkflow
+    : isPlainObject(assetsConfig.releaseAssets)
+      ? assetsConfig.releaseAssets
+      : {};
+
+  if (installerConfig.enabled !== false) {
+    entries.push({
+      template: 'asset_deno_binary_installer',
+      files: [{ from: 'install.sh', to: installerConfig.file || 'install.sh', mode: '0755' }],
+    });
+  }
+
+  if (npmWrapperConfig.enabled === true) {
+    entries.push({
+      template: 'asset_deno_binary_postinstall',
+      files: [
+        {
+          from: 'scripts/install-binary.js',
+          to: npmWrapperConfig.postinstallFile || 'scripts/install-binary.js',
+          mode: '0755',
+        },
+        {
+          from: 'bin/wrapper.js',
+          to: npmWrapperConfig.binFile || `bin/${cliName}-wrapper.js`,
+          mode: '0755',
+        },
+      ],
+    });
+  }
+
+  if (releaseWorkflowConfig.enabled !== false) {
+    entries.push({
+      template: 'asset_deno_binary_release_gitea',
+      files: [{ from: '.gitea/workflows/release.yml', to: releaseWorkflowConfig.file || '.gitea/workflows/release.yml' }],
+    });
+  }
+
+  return entries;
+};
+
+export class AssetsFormatter extends BaseFormatter {
+  get name(): string {
+    return 'assets';
+  }
+
+  async analyze(): Promise<IPlannedChange[]> {
+    const assetsConfig = await getCliConfigValue<Record<string, any> | undefined>('assets', undefined);
+    if (!isPlainObject(assetsConfig) || assetsConfig.enabled === false) {
+      logVerbose('No @git.zone/cli.assets config found, skipping');
+      return [];
+    }
+
+    const smartconfigData = await readSmartconfigFile(paths.cwd);
+    const renderData = await this.buildRenderData(assetsConfig, smartconfigData);
+    const entries = this.getTemplateEntries(assetsConfig, renderData.cliName);
+    const changes: IPlannedChange[] = [];
+
+    for (const entry of entries) {
+      if (entry.enabled === false) {
+        continue;
+      }
+      const renderedFiles = await this.renderTemplate(entry.template, {
+        ...renderData,
+        ...(entry.variables || {}),
+      });
+
+      for (const file of entry.files || []) {
+        const content = renderedFiles.get(file.from) || renderedFiles.get(file.to);
+        if (content === undefined) {
+          throw new Error(`Managed asset ${entry.template}/${file.from} did not render a file`);
+        }
+
+        const destExists = await plugins.smartfs.file(file.to).exists();
+        const currentContent = destExists
+          ? ((await plugins.smartfs.file(file.to).encoding('utf8').read()) as string)
+          : '';
+        const normalizedMode = this.normalizeFileMode(file.mode);
+        const currentMode = normalizedMode ? await this.getFileMode(file.to) : undefined;
+        const needsContentChange = content !== currentContent;
+        const needsModeChange = normalizedMode !== undefined && currentMode !== normalizedMode;
+
+        if (needsContentChange || needsModeChange) {
+          changes.push({
+            type: destExists ? 'modify' : 'create',
+            path: file.to,
+            module: this.name,
+            description: `Apply managed asset ${entry.template}/${file.from}`,
+            content: needsContentChange ? content : undefined,
+            mode: normalizedMode,
+          });
+        }
+      }
+    }
+
+    return changes;
+  }
+
+  async validate(): Promise<IFormatWarning[]> {
+    const assetsConfig = await getCliConfigValue<Record<string, any> | undefined>('assets', undefined);
+    if (!isPlainObject(assetsConfig) || assetsConfig.enabled === false) {
+      return [];
+    }
+    if (assetsConfig.kind && assetsConfig.kind !== 'denoBinaryCli') {
+      return [{ level: 'error', module: this.name, message: `Unsupported managed asset kind: ${assetsConfig.kind}` }];
+    }
+    const installer = isPlainObject(assetsConfig.installer) ? assetsConfig.installer : {};
+    if (installer.distribution && !['rawBranch', 'releaseAsset'].includes(installer.distribution)) {
+      return [
+        {
+          level: 'error',
+          module: this.name,
+          message: `Unsupported installer distribution: ${installer.distribution}`,
+        },
+      ];
+    }
+    return [];
+  }
+
+  async applyChange(change: IPlannedChange): Promise<void> {
+    if (change.type === 'create') {
+      await this.createFile(change.path, change.content || '', change.mode);
+    } else if (change.type === 'modify') {
+      if (change.content !== undefined) {
+        await this.modifyFile(change.path, change.content, change.mode);
+      } else if (change.mode) {
+        await this.setFileMode(change.path, change.mode);
+      }
+    }
+    logger.log('info', `Applied managed asset to ${change.path}`);
+  }
+
+  private getTemplateEntries(assetsConfig: Record<string, any>, cliName: string): IAssetTemplateEntry[] {
+    if (Array.isArray(assetsConfig.managed)) {
+      return assetsConfig.managed
+        .filter((entry) => isPlainObject(entry) && typeof entry.template === 'string')
+        .map((entry) => ({
+          template: entry.template,
+          enabled: entry.enabled,
+          variables: isPlainObject(entry.variables) ? entry.variables : undefined,
+          files: Array.isArray(entry.files)
+            ? entry.files
+                .filter((file) => isPlainObject(file) && typeof file.from === 'string' && typeof file.to === 'string')
+                .map((file) => ({ from: file.from, to: file.to, mode: file.mode }))
+            : [],
+        }));
+    }
+    return buildDefaultEntries(assetsConfig, cliName);
+  }
+
+  private async renderTemplate(templateName: string, variables: Record<string, any>): Promise<Map<string, string>> {
+    const templateDir = plugins.path.join(paths.templatesDir, templateName);
+    if (!(await plugins.smartfs.directory(templateDir).exists())) {
+      throw new Error(`Managed asset template does not exist: ${templateName}`);
+    }
+
+    const scafTemplate = new plugins.smartscaf.ScafTemplate(templateDir);
+    await scafTemplate.readTemplateFromDir();
+    await scafTemplate.supplyVariables(variables);
+
+    const renderedFiles = await scafTemplate.renderToMemory();
+    const fileMap = new Map<string, string>();
+    for (const file of renderedFiles) {
+      fileMap.set(file.path, file.contents.toString());
+    }
+    return fileMap;
+  }
+
+  private async buildRenderData(
+    assetsConfig: Record<string, any>,
+    smartconfigData: Record<string, any>,
+  ): Promise<Record<string, any>> {
+    const packageJson = await readJsonFile(plugins.path.join(paths.cwd, 'package.json'));
+    const denoJson = await readJsonFile(plugins.path.join(paths.cwd, 'deno.json'));
+    const moduleConfig = this.project.gitzoneConfig?.data?.module || {};
+    const cliName = assetsConfig.cliName || packageJson.name?.split('/').pop() || moduleConfig.gitrepo || 'app';
+    const displayName = assetsConfig.displayName || cliName.toUpperCase();
+    const repository = normalizeRepository(assetsConfig, moduleConfig);
+    const npmPackageName = (moduleConfig as any).npmPackagename || moduleConfig.npmPackageName;
+    const binaryTargets = normalizeBinaryTargets(assetsConfig, smartconfigData);
+    const binaryConfig = isPlainObject(assetsConfig.binary) ? assetsConfig.binary : {};
+    const installerConfig = this.normalizeInstallerConfig(assetsConfig, cliName, repository);
+    const npmWrapperConfig = this.normalizeNpmWrapperConfig(assetsConfig, cliName);
+    const releaseWorkflowConfig = this.normalizeReleaseWorkflowConfig(assetsConfig, binaryConfig, installerConfig);
+
+    return {
+      module: moduleConfig,
+      projectType: this.project.gitzoneConfig?.data?.projectType,
+      packageJson,
+      denoJson,
+      assets: assetsConfig,
+      cliName,
+      cliNameUpper: cliName.toUpperCase(),
+      displayName,
+      packageName: assetsConfig.packageName || packageJson.name || npmPackageName || cliName,
+      versionFallback: packageJson.version || denoJson.version || '0.0.0',
+      repository,
+      binary: {
+        ...binaryConfig,
+        outDir: binaryConfig.outDir || 'dist/binaries',
+        installFileName: binaryConfig.installFileName || cliName,
+        targets: binaryTargets,
+        supportedPlatformText: binaryTargets.map((target) => target.label).join(', '),
+        hasTargets: binaryTargets.length > 0,
+      },
+      installer: installerConfig,
+      npmWrapper: npmWrapperConfig,
+      releaseWorkflow: releaseWorkflowConfig,
+    };
+  }
+
+  private normalizeInstallerConfig(
+    assetsConfig: Record<string, any>,
+    cliName: string,
+    repository: Record<string, any>,
+  ): Record<string, any> {
+    const installer = isPlainObject(assetsConfig.installer) ? assetsConfig.installer : {};
+    const modes = isPlainObject(installer.modes) ? installer.modes : {};
+    const source = isPlainObject(modes.source) ? modes.source : isPlainObject(installer.source) ? installer.source : {};
+    const service = isPlainObject(installer.service) ? installer.service : {};
+    const file = installer.file || 'install.sh';
+    const releaseAssetName = plugins.path.basename(file);
+    const distribution = installer.distribution || installer.delivery || 'rawBranch';
+    const versionSelection = uniqueStringArray(installer.versionSelection, ['latest', 'version']);
+    const detectNames = uniqueStringArray(service.detectNames, service.name ? [service.name] : [cliName]);
+    const removeLegacyUnits = uniqueStringArray(service.removeLegacyUnits || service.legacyUnitNames || []);
+    const ensureDirs = uniqueStringArray(installer.ensureDirs);
+    const preservePaths = uniqueStringArray(installer.preservePaths);
+    const successHints = uniqueStringArray(installer.successHints, [`${cliName} --version`, `${cliName} --help`]);
+    const rawBranchInstallUrl = `${repository.baseUrl}/raw/branch/${repository.branch}/${file}`;
+    const releaseAssetInstallUrl = `${repository.baseUrl}/releases/download/<version>/${releaseAssetName}`;
+    const releaseNotesInstallUrl = `${repository.baseUrl}/releases/download/$VERSION/${releaseAssetName}`;
+
+    return {
+      ...installer,
+      enabled: installer.enabled !== false,
+      file,
+      distribution,
+      releaseAssetName,
+      publicInstallUrl: distribution === 'releaseAsset' ? releaseAssetInstallUrl : rawBranchInstallUrl,
+      releaseNotesInstallUrl: distribution === 'releaseAsset' ? releaseNotesInstallUrl : rawBranchInstallUrl,
+      installDir: installer.installDir || `/opt/${cliName}`,
+      binDir: installer.binDir || '/usr/local/bin',
+      defaultMode: modes.default || installer.defaultMode || 'binary',
+      versionSelection,
+      supportsMajor: versionSelection.includes('major'),
+      source: {
+        ...source,
+        enabled: source.enabled === true,
+        commands: uniqueStringArray(source.commands),
+        executable: source.executable || 'cli.js',
+        executableFiles: uniqueStringArray(source.executableFiles, source.executable ? [source.executable] : ['cli.js']),
+        validateCommand: source.validate || source.validateCommand || `node ${source.executable || 'cli.js'} --version`,
+      },
+      service: {
+        ...service,
+        detectNames,
+        removeLegacyUnits,
+        hasLegacyUnitRemoval: removeLegacyUnits.length > 0,
+        restartName: service.restartName || detectNames[0] || cliName,
+        hasRefreshCommand: typeof service.refreshCommand === 'string' && service.refreshCommand.trim().length > 0,
+      },
+      ensureDirs,
+      preservePaths,
+      primaryPreservePath: preservePaths[0],
+      hasPreservePaths: preservePaths.length > 0,
+      successHints,
+    };
+  }
+
+  private normalizeNpmWrapperConfig(assetsConfig: Record<string, any>, cliName: string): Record<string, any> {
+    const npmWrapper = isPlainObject(assetsConfig.npmWrapper) ? assetsConfig.npmWrapper : {};
+    return {
+      ...npmWrapper,
+      enabled: npmWrapper.enabled === true,
+      binFile: npmWrapper.binFile || `bin/${cliName}-wrapper.js`,
+      postinstallFile: npmWrapper.postinstallFile || 'scripts/install-binary.js',
+      binariesDir: npmWrapper.binariesDir || 'dist/binaries',
+    };
+  }
+
+  private normalizeReleaseWorkflowConfig(
+    assetsConfig: Record<string, any>,
+    binaryConfig: Record<string, any>,
+    installerConfig: Record<string, any>,
+  ): Record<string, any> {
+    const releaseWorkflow = isPlainObject(assetsConfig.releaseWorkflow)
+      ? assetsConfig.releaseWorkflow
+      : isPlainObject(assetsConfig.releaseAssets)
+        ? assetsConfig.releaseAssets
+        : {};
+    const binaryOutDir = binaryConfig.outDir || 'dist/binaries';
+    const assetGlobs = uniqueStringArray(releaseWorkflow.assetGlobs || releaseWorkflow.include, [`${binaryOutDir}/*`]);
+    const includeInstallerAsset =
+      typeof releaseWorkflow.includeInstallerAsset === 'boolean'
+        ? releaseWorkflow.includeInstallerAsset
+        : installerConfig.enabled !== false && installerConfig.distribution === 'releaseAsset';
+    return {
+      ...releaseWorkflow,
+      enabled: releaseWorkflow.enabled !== false,
+      file: releaseWorkflow.file || '.gitea/workflows/release.yml',
+      installCommand: releaseWorkflow.installCommand || 'pnpm install --ignore-scripts',
+      compileCommand: releaseWorkflow.compileCommand || 'pnpm exec tsdeno compile',
+      packNpmArtifact: releaseWorkflow.packNpmArtifact === true,
+      includeInstallerAsset,
+      assetGlobs,
+      keepReleases: releaseWorkflow.keepReleases ?? 0,
+      binaryOutDir,
+    };
+  }
+}

package/ts/mod_format/formatters/packagejson.formatter.ts

@@ -70,8 +70,41 @@ export class PackageJsonFormatter extends BaseFormatter {
       packageJson.scripts.build = `echo "Not needed for now"`;
     }
 
+    const rawAssetsConfig = gitzoneData.assets;
+    const assetsConfig = rawAssetsConfig?.enabled === false ? undefined : rawAssetsConfig;
+    const managedAssetConfig = rawAssetsConfig?.kind === 'denoBinaryCli' ? rawAssetsConfig : undefined;
+    const managedCliName = managedAssetConfig?.cliName || packageJson.name?.split('/').pop();
+    const managedBinFile = managedAssetConfig?.npmWrapper?.binFile || `bin/${managedCliName}-wrapper.js`;
+    const managedPostinstallFile = managedAssetConfig?.npmWrapper?.postinstallFile || 'scripts/install-binary.js';
+    const managedPostinstallCommand = `node ${managedPostinstallFile}`;
+
+    if (assetsConfig?.kind === 'denoBinaryCli' && assetsConfig.npmWrapper?.enabled) {
+      if (managedCliName) {
+        packageJson.bin = typeof packageJson.bin === 'object' && !Array.isArray(packageJson.bin)
+          ? packageJson.bin
+          : {};
+        packageJson.bin[managedCliName] = `./${managedBinFile}`;
+      }
+      packageJson.scripts.postinstall = managedPostinstallCommand;
+    } else if (managedAssetConfig) {
+      if (
+        managedCliName &&
+        typeof packageJson.bin === 'object' &&
+        !Array.isArray(packageJson.bin) &&
+        packageJson.bin[managedCliName] === `./${managedBinFile}`
+      ) {
+        delete packageJson.bin[managedCliName];
+        if (Object.keys(packageJson.bin).length === 0) {
+          delete packageJson.bin;
+        }
+      }
+      if (packageJson.scripts.postinstall === managedPostinstallCommand) {
+        delete packageJson.scripts.postinstall;
+      }
+    }
+
     // Set files array
-    packageJson.files = [
+    const files = [
       'ts/**/*',
       'ts_web/**/*',
       'dist/**/*',
@@ -84,6 +117,15 @@ export class PackageJsonFormatter extends BaseFormatter {
       'readme.md',
     ];
 
+    if (assetsConfig?.kind === 'denoBinaryCli' && assetsConfig.installer?.enabled !== false) {
+      files.push(assetsConfig.installer?.file || 'install.sh');
+    }
+    if (assetsConfig?.kind === 'denoBinaryCli' && assetsConfig.npmWrapper?.enabled) {
+      files.push('bin/');
+      files.push(assetsConfig.npmWrapper.postinstallFile || 'scripts/install-binary.js');
+    }
+    packageJson.files = [...new Set(files)];
+
     // Set pnpm overrides from assets
     try {
       const overridesContent = (await plugins.smartfs

package/ts/mod_format/index.ts

@@ -17,6 +17,7 @@ import { SmartconfigFormatter } from "./formatters/smartconfig.formatter.js";
 import { LicenseFormatter } from "./formatters/license.formatter.js";
 import { PackageJsonFormatter } from "./formatters/packagejson.formatter.js";
 import { TemplatesFormatter } from "./formatters/templates.formatter.js";
+import { AssetsFormatter } from "./formatters/assets.formatter.js";
 import { GitignoreFormatter } from "./formatters/gitignore.formatter.js";
 import { TsconfigFormatter } from "./formatters/tsconfig.formatter.js";
 import { PrettierFormatter } from "./formatters/prettier.formatter.js";
@@ -61,6 +62,7 @@ const formatterMap: Record<
   license: LicenseFormatter,
   packagejson: PackageJsonFormatter,
   templates: TemplatesFormatter,
+  assets: AssetsFormatter,
   gitignore: GitignoreFormatter,
   tsconfig: TsconfigFormatter,
   prettier: PrettierFormatter,
@@ -206,6 +208,7 @@ const serializePlan = (plan: any) => {
       path: change.path,
       module: change.module,
       description: change.description,
+      mode: change.mode,
     })),
   };
 };

package/ts/mod_format/interfaces.format.ts

@@ -21,6 +21,7 @@ export type IPlannedChange = {
   module: string;
   description: string;
   content?: string; // New content for create/modify operations
+  mode?: string; // Optional file mode, e.g. 0755 for generated executables
 };
 
 export interface ICheckResult {
@@ -30,6 +31,8 @@ export interface ICheckResult {
     type: 'create' | 'modify' | 'delete';
     before?: string;
     after?: string;
+    modeBefore?: string;
+    modeAfter?: string;
   }>;
 }
 
@@ -44,6 +47,7 @@ export function getModuleIcon(module: string): string {
     readme: '📖',
     templates: '📄',
     smartconfig: '⚙️',
+    assets: '🧩',
     copy: '📋',
   };
   return icons[module] || '📁';