@doki-land/nifty 0.0.12 → 0.1.1

package/src/cli/trust-cmd.ts

@@ -3,11 +3,12 @@ import type { Cli, ParsedOptions } from "@vmz/commander";
 import { loadNiftyNative } from "../native.js";
 import { authPayload } from "./authArgs.js";
 import { loadConfig } from "../config/loadConfig.js";
+import { trustPayloadFromConfig } from "../config/trustPayload.js";
 import { bootstrapFromOptions } from "./context.js";
 import { printTrustReport } from "./trust.js";
 import { authFromOptions, cwdFrom, flag, str } from "./options.js";
 
-export function registerTrustCommand(cli: Cli): void {
+export function registerTrustCommand(cli : Cli) : void {
     cli.command("trust", "cli.cmd.trust")
         .option("--dry-run", "cli.opt.dry-run")
         .option("--refresh", "cli.opt.refresh")
@@ -15,23 +16,25 @@ export function registerTrustCommand(cli: Cli): void {
         .option("--otp <code>", "cli.opt.otp")
         .option("--totp-secret <secret>", "cli.opt.totp-secret")
         .option("--npm-token <token>", "cli.opt.npm-token")
-        .action(async (options) => cmdTrust(options));
+        .action(async(options) =>cmdTrust(options));
 }
 
-export async function cmdTrust(options: ParsedOptions): Promise<number> {
+export async function cmdTrust(options : ParsedOptions) : Promise<number>{
     await bootstrapFromOptions(options);
-    const { config } = await loadConfig({ cwd: cwdFrom(options), createIfMissing: false });
+    const { config } = await loadConfig({ cwd : cwdFrom(options), createIfMissing : false });
     const native = loadNiftyNative();
+    const fromConfig = config.publish ?.packages ?? [];
     const report = native.publisher["trust-workspace"]({
-        cwd: cwdFrom(options),
-        dryRun: flag(options, "dry-run"),
-        refresh: flag(options, "refresh"),
-        only: str(options, "only"),
-        packages: config.publish?.packages,
+        cwd : cwdFrom(options),
+        dryRun : flag(options, "dry-run"),
+        refresh : flag(options, "refresh"),
+        only : str(options, "only"),
+        ...(fromConfig.length>0 ? { packages : fromConfig } : { }),
+        ...trustPayloadFromConfig(config),
         ...authPayload(authFromOptions(options)),
     });
     printTrustReport(report);
-    if (report.failed.length > 0) {
+    if(report.failed.length>0){
         throw new Error(`trust failed for ${report.failed.length} package(s)`);
     }
     return 0;

package/src/cli/trust.ts

@@ -2,43 +2,43 @@ import { loadNiftyNative } from "../native.js";
 import { authPayload, parseAuthArgs } from "./authArgs.js";
 
 export type TrustReport = {
-    root: string;
-    configured: string[];
-    skipped: string[];
-    failed: string[];
+    root : string;
+    configured : string[];
+    skipped : string[];
+    failed : string[];
 };
 
-export async function runTrust(argv: string[]): Promise<void> {
+export async function runTrust(argv : string[]) : Promise<void>{
     const options = parseTrustArgs(argv);
     const native = loadNiftyNative();
     const report = native.publisher["trust-workspace"]({
-        cwd: options.cwd,
-        dryRun: options.dryRun,
-        refresh: options.refresh,
-        only: options.only,
+        cwd : options.cwd,
+        dryRun : options.dryRun,
+        refresh : options.refresh,
+        only : options.only,
         ...authPayload(options.auth),
     });
     printTrustReport(report);
 }
 
-function parseTrustArgs(argv: string[]) {
-    let cwd: string | undefined;
+function parseTrustArgs(argv : string[]){
+    let cwd : string | undefined;
     let dryRun = false;
     let refresh = false;
-    let only: string | undefined;
+    let only : string | undefined;
     const auth = parseAuthArgs(argv);
 
-    for (let i = 0; i < argv.length; i += 1) {
+    for(let i = 0; i<argv.length; i += 1){
         const arg = argv[i];
-        if (arg === "--dry-run") {
+        if(arg === "--dry-run"){
             dryRun = true;
-        } else if (arg === "--refresh") {
+        } else if(arg === "--refresh"){
             refresh = true;
-        } else if (arg === "-C" || arg === "--cwd") {
-            cwd = argv[++i];
-        } else if (arg === "--only") {
-            only = argv[++i];
-        } else if (arg === "-h" || arg === "--help") {
+        } else if(arg === "-C" || arg === "--cwd"){
+            cwd = argv[ ++ i];
+        } else if(arg === "--only"){
+            only = argv[ ++ i];
+        } else if(arg === "-h" || arg === "--help"){
             printTrustHelp();
             process.exit(0);
         }
@@ -47,29 +47,32 @@ function parseTrustArgs(argv: string[]) {
     return { cwd, dryRun, refresh, only, auth };
 }
 
-export function printTrustReport(report: TrustReport): void {
+export function printTrustReport(report : TrustReport) : void {
     console.log(`trust workspace ${report.root}`);
     console.log(`  configured: ${report.configured.length}`);
-    for (const name of report.configured) {
+    for(const name of report.configured){
         console.log(`    + ${name}`);
     }
     console.log(`  skipped: ${report.skipped.length}`);
-    for (const name of report.skipped) {
+    for(const name of report.skipped){
         console.log(`    = ${name}`);
     }
-    if (report.failed.length > 0) {
+    if(report.failed.length>0){
         console.log(`  failed: ${report.failed.length}`);
-        for (const name of report.failed) {
+        for(const name of report.failed){
             console.log(`    ! ${name}`);
         }
     }
 }
 
-function printTrustHelp(): void {
+function printTrustHelp() : void {
     console.log(`nifty trust — configure npm Trusted Publisher for workspace packages
 
-Reads NPM_TOTP_SECRET / NPM_OTP / NPM_TOKEN from env or .env.placeholder.local.
+Reads trust.npm from nifty.config.ts (repo / file / environment).
+Auth: NPM_TOKEN from env or .env.placeholder.local, or npm login token in project .npmrc / ~/.npmrc.
+Optional NPM_TOTP_SECRET / NPM_OTP for 2FA accounts (npm-otp header).
 Trust list cache lives in .cache/npm-placeholder.json.
+Uses the npm registry API (/-/package/*/trust), not npm trust CLI.
 
 Usage:
   nifty trust

package/src/cli/update-cmd.ts

@@ -4,17 +4,17 @@ import { bootstrapFromOptions } from "./context.js";
 import { updateWorkspace } from "./update.js";
 import { cwdFrom, flag } from "./options.js";
 
-export function registerUpdateCommand(cli: Cli): void {
+export function registerUpdateCommand(cli : Cli) : void {
     cli.command("update", "cli.cmd.update")
         .option("-i, --interactive", "cli.opt.interactive")
-        .action(async (options) => cmdUpdate(options));
+        .action(async(options) =>cmdUpdate(options));
 }
 
-export async function cmdUpdate(options: ParsedOptions): Promise<number> {
+export async function cmdUpdate(options : ParsedOptions) : Promise<number>{
     await bootstrapFromOptions(options);
     await updateWorkspace({
-        interactive: flag(options, "interactive"),
-        cwd: cwdFrom(options),
+        interactive : flag(options, "interactive"),
+        cwd : cwdFrom(options),
     });
     return 0;
 }

package/src/cli/update.ts

@@ -1,31 +1,31 @@
 import { loadNiftyNative } from "../native.js";
 
 export type UpdateOptions = {
-    interactive: boolean;
-    cwd?: string;
+    interactive : boolean;
+    cwd ? : string;
 };
 
-export async function runUpdate(argv: string[]): Promise<void> {
+export async function runUpdate(argv : string[]) : Promise<void>{
     await updateWorkspace(parseUpdateArgs(argv));
 }
 
-export async function updateWorkspace(options: UpdateOptions): Promise<void> {
+export async function updateWorkspace(options : UpdateOptions) : Promise<void>{
     const native = loadNiftyNative();
     native.updater.run({
-        cwd: options.cwd,
-        interactive: options.interactive,
+        cwd : options.cwd,
+        interactive : options.interactive,
     });
 }
 
-function parseUpdateArgs(argv: string[]): UpdateOptions {
+function parseUpdateArgs(argv : string[]) : UpdateOptions {
     let interactive = false;
-    let cwd: string | undefined;
-    for (let i = 0; i < argv.length; i += 1) {
+    let cwd : string | undefined;
+    for(let i = 0; i<argv.length; i += 1){
         const arg = argv[i];
-        if (arg === "-i" || arg === "--interactive") {
+        if(arg === "-i" || arg === "--interactive"){
             interactive = true;
-        } else if (arg === "-C" || arg === "--cwd") {
-            cwd = argv[++i];
+        } else if(arg === "-C" || arg === "--cwd"){
+            cwd = argv[ ++ i];
         }
     }
     return { interactive, cwd };

package/src/cli/upload-cmd.ts

@@ -4,7 +4,7 @@ import { bootstrapFromOptions } from "./context.js";
 import { uploadFromOptions } from "./upload.js";
 import { cwdFrom, flag, str } from "./options.js";
 
-export function registerUploadCommand(cli: Cli): void {
+export function registerUploadCommand(cli : Cli) : void {
     cli.command("upload", "cli.cmd.upload")
         .option("--release", "cli.opt.release")
         .option("--pages", "cli.opt.pages")
@@ -19,26 +19,26 @@ export function registerUploadCommand(cli: Cli): void {
         .option("--draft", "cli.opt.draft")
         .option("--no-generate-notes", "cli.opt.no-generate-notes")
         .option("--github-action", "cli.opt.github-action")
-        .action(async (options) => cmdUpload(options));
+        .action(async(options) =>cmdUpload(options));
 }
 
-export async function cmdUpload(options: ParsedOptions): Promise<number> {
+export async function cmdUpload(options : ParsedOptions) : Promise<number>{
     await bootstrapFromOptions(options);
     await uploadFromOptions({
-        release: flag(options, "release"),
-        pages: flag(options, "pages"),
-        both: flag(options, "both"),
-        dir: str(options, "dir") ?? "dist",
-        tag: str(options, "tag"),
-        repo: str(options, "repo"),
-        token: str(options, "token"),
-        name: str(options, "name"),
-        notes: str(options, "notes"),
-        notesFile: str(options, "notes-file"),
-        draft: flag(options, "draft"),
-        generateNotes: !flag(options, "no-generate-notes"),
-        githubAction: flag(options, "github-action"),
-        cwd: cwdFrom(options),
+        release : flag(options, "release"),
+        pages : flag(options, "pages"),
+        both : flag(options, "both"),
+        dir : str(options, "dir") ?? "dist",
+        tag : str(options, "tag"),
+        repo : str(options, "repo"),
+        token : str(options, "token"),
+        name : str(options, "name"),
+        notes : str(options, "notes"),
+        notesFile : str(options, "notes-file"),
+        draft : flag(options, "draft"),
+        generateNotes : !flag(options, "no-generate-notes"),
+        githubAction : flag(options, "github-action"),
+        cwd : cwdFrom(options),
     });
     return 0;
 }