@gmickel/gno 1.25.1 → 1.26.0

package/src/cli/commands/setup-activation.ts

@@ -5,11 +5,10 @@ import type {
   SetupConnectorState,
 } from "../../core/setup-activation";
 import type { SqliteAdapter } from "../../store/sqlite/adapter";
-import type {
-  SetupCommandOptions,
-  SetupCommandOutcome,
-  SetupCommandResult,
-} from "./setup";
+import type { ProjectProfileCommandResult } from "./profile";
+import type { ProjectProfileApplyCommandResult } from "./profile-apply";
+import type { SetupCommandOutcome, SetupCommandResult } from "./setup";
+import type { SetupProfileIntegrationOptions } from "./setup-profile";
 
 import { getIndexDbPath } from "../../app/constants";
 import { getConfigPaths, loadConfig, toAbsolutePath } from "../../config";
@@ -31,6 +30,16 @@ import {
   SETUP_COMMAND_SCHEMA_VERSION,
   setup,
 } from "./setup";
+import {
+  applySetupProfile,
+  inspectSetupProfile,
+  profileApplyFailureOutcome,
+  profileApplySucceeded,
+  profileInspectionFailureOutcome,
+  setupOptionsAfterProfileApply,
+} from "./setup-profile";
+
+export { formatSetupProfileAdvisory } from "./setup-profile";
 
 export interface SetupActivationResult {
   schemaVersion: typeof SETUP_ACTIVATION_SCHEMA_VERSION;
@@ -39,26 +48,38 @@ export interface SetupActivationResult {
   connectors: SetupConnectorResult[];
 }
 
-export type SetupOutputResult = SetupCommandResult | SetupActivationResult;
+export interface SetupProfileResult {
+  schemaVersion: "1.0";
+  status: "completed" | "completed_with_actions" | "failed";
+  profile: {
+    check: ProjectProfileCommandResult;
+    apply: ProjectProfileApplyCommandResult | null;
+  };
+  setup: SetupCommandResult;
+  connectors: SetupConnectorResult[];
+}
+
+export type SetupOutputResult =
+  | SetupCommandResult
+  | SetupActivationResult
+  | SetupProfileResult;
 
 export interface SetupOutputOutcome {
   result: SetupOutputResult;
   exitCode: 0 | 1 | 2;
 }
 
-export interface SetupProfileAdvisoryInput {
-  folder: string;
-  collection: string;
+function isComposedSetupResult(
+  result: SetupOutputResult
+): result is SetupActivationResult | SetupProfileResult {
+  return "setup" in result;
 }
 
-export interface SetupActivationCommandOptions extends SetupCommandOptions {
+export interface SetupActivationCommandOptions extends SetupProfileIntegrationOptions {
   connectorIds?: string[];
   connectorWorkspace?: { cwd?: string; homeDir?: string };
   connectorDeps?: SetupConnectorCompositionDeps;
   createActivationStore?: () => SqliteAdapter;
-  discoverProfileAdvisory?: (
-    input: SetupProfileAdvisoryInput
-  ) => Promise<unknown>;
 }
 
 function dedupeConnectorIds(connectorIds: string[]): string[] {
@@ -115,6 +136,27 @@ function invalidConnectorOutcome(connectorIds: string[]): SetupCommandOutcome {
   };
 }
 
+function profileOptionConflictOutcome(): SetupCommandOutcome {
+  return {
+    result: {
+      schemaVersion: SETUP_COMMAND_SCHEMA_VERSION,
+      status: "failed",
+      lexical: {
+        receipt: null,
+        error: {
+          code: "profile_option_conflict",
+          message:
+            "--apply-profile cannot be combined with explicit --name or --exclude options.",
+          remediation:
+            "Remove the explicit setup overrides or run setup without --apply-profile.",
+        },
+      },
+      semantic: null,
+    },
+    exitCode: 1,
+  };
+}
+
 function failedSetupActivationOutcome(
   setupOutcome: SetupCommandOutcome
 ): SetupOutputOutcome {
@@ -158,18 +200,37 @@ function defaultConnectorDeps(
   };
 }
 
-async function discoverProfileAdvisory(
-  discover: SetupActivationCommandOptions["discoverProfileAdvisory"],
-  input: SetupProfileAdvisoryInput
-): Promise<void> {
-  if (!discover) {
-    return;
-  }
-  try {
-    await discover(input);
-  } catch {
-    // Advisory discovery cannot mutate or fail verified setup.
-  }
+function withProfileResult(
+  outcome: SetupOutputOutcome,
+  requested: boolean,
+  check: ProjectProfileCommandResult | null,
+  applied: ProjectProfileApplyCommandResult | null
+): SetupOutputOutcome {
+  if (!requested || !check) return outcome;
+  const setupResult = isComposedSetupResult(outcome.result)
+    ? outcome.result.setup
+    : outcome.result;
+  const connectors = isComposedSetupResult(outcome.result)
+    ? outcome.result.connectors
+    : [];
+  const profileCompleted =
+    applied?.status === "applied" || applied?.status === "unchanged";
+  return {
+    exitCode: outcome.exitCode,
+    result: {
+      schemaVersion: "1.0",
+      status:
+        setupResult.status === "failed"
+          ? "failed"
+          : outcome.result.status === "completed_with_actions" ||
+              !profileCompleted
+            ? "completed_with_actions"
+            : "completed",
+      profile: { check, apply: applied },
+      setup: setupResult,
+      connectors,
+    },
+  };
 }
 
 function withUnavailableConnectors(
@@ -220,17 +281,87 @@ export async function setupWithActivation(
     connectorWorkspace: _connectorWorkspace,
     connectorDeps: _connectorDeps,
     createActivationStore: _createActivationStore,
-    discoverProfileAdvisory: _discoverProfileAdvisory,
+    applyProfile: _applyProfile,
+    inspectProfileAdvisory: _inspectProfileAdvisory,
+    applyProfileAdvisory: _applyProfileAdvisory,
+    onProfileAdvisory: _onProfileAdvisory,
+    onProfileApply: _onProfileApply,
     ...setupOptions
   } = options;
-  const setupOutcome = await setup(setupOptions);
+  const profileInspection = await inspectSetupProfile(options);
+  const profileCheck = profileInspection.result;
+  if (options.applyProfile && profileInspection.failed) {
+    const failedInspection = profileInspectionFailureOutcome();
+    return definitions.length > 0
+      ? failedSetupActivationOutcome(failedInspection)
+      : failedInspection;
+  }
+  if (
+    options.applyProfile &&
+    profileCheck?.status === "valid" &&
+    (options.name !== undefined || (options.exclude?.length ?? 0) > 0)
+  ) {
+    return withProfileResult(
+      definitions.length > 0
+        ? failedSetupActivationOutcome(profileOptionConflictOutcome())
+        : profileOptionConflictOutcome(),
+      true,
+      profileCheck,
+      null
+    );
+  }
+  const profileApplyOutcome = await applySetupProfile(options, profileCheck);
+  const profileApplySuccess = profileApplySucceeded(profileApplyOutcome);
+  const returnedProfileApply = profileApplyOutcome?.result ?? null;
+  const profileApply =
+    profileApplyOutcome?.exitCode === 0 && !profileApplySuccess
+      ? null
+      : returnedProfileApply;
+  if (
+    options.applyProfile &&
+    profileCheck?.status === "valid" &&
+    !profileApplySuccess
+  ) {
+    const failedApply = profileApplyFailureOutcome(profileApplyOutcome);
+    return withProfileResult(
+      definitions.length > 0
+        ? failedSetupActivationOutcome(failedApply)
+        : failedApply,
+      true,
+      profileCheck,
+      profileApply
+    );
+  }
+  const effectiveSetupOptions = await setupOptionsAfterProfileApply(
+    setupOptions,
+    profileApply
+  );
+  if (effectiveSetupOptions === null) {
+    const failedApply = profileApplyFailureOutcome(profileApplyOutcome);
+    return withProfileResult(
+      definitions.length > 0
+        ? failedSetupActivationOutcome(failedApply)
+        : failedApply,
+      true,
+      profileCheck,
+      profileApply
+    );
+  }
+  const setupOutcome = await setup(effectiveSetupOptions);
   if (
     setupOutcome.exitCode !== 0 ||
     setupOutcome.result.status !== "completed"
   ) {
-    return definitions.length > 0
-      ? failedSetupActivationOutcome(setupOutcome)
-      : setupOutcome;
+    const failed =
+      definitions.length > 0
+        ? failedSetupActivationOutcome(setupOutcome)
+        : setupOutcome;
+    return withProfileResult(
+      failed,
+      Boolean(options.applyProfile),
+      profileCheck,
+      profileApply
+    );
   }
 
   const lexicalReceipt = setupOutcome.result.lexical.receipt;
@@ -240,15 +371,21 @@ export async function setupWithActivation(
     !collection ||
     !lexicalSuccessIsProven(lexicalReceipt)
   ) {
-    return setupOutcome;
+    return withProfileResult(
+      setupOutcome,
+      Boolean(options.applyProfile),
+      profileCheck,
+      profileApply
+    );
   }
 
-  await discoverProfileAdvisory(options.discoverProfileAdvisory, {
-    folder: lexicalReceipt.input.folder,
-    collection,
-  });
   if (definitions.length === 0) {
-    return setupOutcome;
+    return withProfileResult(
+      setupOutcome,
+      Boolean(options.applyProfile),
+      profileCheck,
+      profileApply
+    );
   }
 
   let store: SqliteAdapter | null = null;
@@ -258,7 +395,12 @@ export async function setupWithActivation(
     const indexName = options.indexName ?? "default";
     const configResult = await loadConfig(configPath);
     if (!configResult.ok) {
-      return withUnavailableConnectors(setupOutcome.result, definitions);
+      return withProfileResult(
+        withUnavailableConnectors(setupOutcome.result, definitions),
+        Boolean(options.applyProfile),
+        profileCheck,
+        profileApply
+      );
     }
 
     store =
@@ -270,7 +412,12 @@ export async function setupWithActivation(
       configResult.value.ftsTokenizer
     );
     if (!opened.ok) {
-      return withUnavailableConnectors(setupOutcome.result, definitions);
+      return withProfileResult(
+        withUnavailableConnectors(setupOutcome.result, definitions),
+        Boolean(options.applyProfile),
+        profileCheck,
+        profileApply
+      );
     }
 
     const composition = await composeSetupConnectors({
@@ -283,28 +430,32 @@ export async function setupWithActivation(
         options.connectorDeps ??
         defaultConnectorDeps(options.connectorWorkspace),
     });
-    return {
-      result: {
-        schemaVersion: SETUP_ACTIVATION_SCHEMA_VERSION,
-        status: composition.status,
-        setup: setupOutcome.result,
-        connectors: composition.connectors,
+    return withProfileResult(
+      {
+        result: {
+          schemaVersion: SETUP_ACTIVATION_SCHEMA_VERSION,
+          status: composition.status,
+          setup: setupOutcome.result,
+          connectors: composition.connectors,
+        },
+        exitCode: 0,
       },
-      exitCode: 0,
-    };
+      Boolean(options.applyProfile),
+      profileCheck,
+      profileApply
+    );
   } catch {
-    return withUnavailableConnectors(setupOutcome.result, definitions);
+    return withProfileResult(
+      withUnavailableConnectors(setupOutcome.result, definitions),
+      Boolean(options.applyProfile),
+      profileCheck,
+      profileApply
+    );
   } finally {
     await closeActivationStore(store);
   }
 }
 
-function isSetupActivationResult(
-  result: SetupOutputResult
-): result is SetupActivationResult {
-  return "setup" in result;
-}
-
 export function formatSetupOutputResult(
   result: SetupOutputResult,
   options: { json: boolean }
@@ -312,7 +463,7 @@ export function formatSetupOutputResult(
   if (options.json) {
     return JSON.stringify(result, null, 2);
   }
-  if (!isSetupActivationResult(result)) {
+  if (!isComposedSetupResult(result)) {
     return formatSetupResult(result, options);
   }
   const setupOutput = formatSetupResult(result.setup, options);

package/src/cli/commands/setup-profile.ts

@@ -0,0 +1,223 @@
+/**
+ * Optional project-profile composition for `gno setup`.
+ *
+ * Inspection is always read-only and non-fatal. Application requires the
+ * explicit `--apply-profile` request and reuses the lock-safe profile command.
+ *
+ * @module src/cli/commands/setup-profile
+ */
+
+import type {
+  ProjectProfileCommandOutcome,
+  ProjectProfileCommandResult,
+} from "./profile";
+import type {
+  ProjectProfileApplyCommandOutcome,
+  ProjectProfileApplyCommandResult,
+} from "./profile-apply";
+import type { SetupCommandOptions, SetupCommandOutcome } from "./setup";
+
+import { loadConfig } from "../../config";
+import { isProjectProfileApplyReceipt } from "../../core/project-profile-apply-validation";
+import { runProjectProfileCommand } from "./profile";
+import { SETUP_COMMAND_SCHEMA_VERSION } from "./setup";
+
+export interface SetupProfileAdvisoryInput {
+  folder: string;
+  configPath?: string;
+  offline?: boolean;
+}
+
+export interface SetupProfileIntegrationOptions extends SetupCommandOptions {
+  applyProfile?: boolean;
+  inspectProfileAdvisory?: (
+    input: SetupProfileAdvisoryInput
+  ) => Promise<ProjectProfileCommandOutcome>;
+  applyProfileAdvisory?: (
+    input: SetupProfileAdvisoryInput
+  ) => Promise<ProjectProfileApplyCommandOutcome>;
+  onProfileAdvisory?: (result: ProjectProfileCommandResult) => void;
+  onProfileApply?: (result: ProjectProfileApplyCommandResult) => void;
+}
+
+export interface SetupProfileInspectionOutcome {
+  result: ProjectProfileCommandResult | null;
+  failed: boolean;
+}
+
+export function profileInspectionFailureOutcome(): SetupCommandOutcome {
+  return {
+    result: {
+      schemaVersion: SETUP_COMMAND_SCHEMA_VERSION,
+      status: "failed",
+      lexical: {
+        receipt: null,
+        error: {
+          code: "profile_inspection_failed",
+          message:
+            "The requested project profile could not be inspected safely before setup.",
+          remediation:
+            "Run `gno profile check` for diagnostics, repair the reported problem, and retry setup.",
+        },
+      },
+      semantic: null,
+    },
+    exitCode: 2,
+  };
+}
+
+export function profileApplyFailureOutcome(
+  outcome: ProjectProfileApplyCommandOutcome | null
+): SetupCommandOutcome {
+  return {
+    result: {
+      schemaVersion: SETUP_COMMAND_SCHEMA_VERSION,
+      status: "failed",
+      lexical: {
+        receipt: null,
+        error: {
+          code: "profile_apply_failed",
+          message:
+            "The valid project profile could not be applied safely before setup.",
+          remediation:
+            "Run `gno profile apply` for diagnostics, repair the reported problem, and retry setup.",
+        },
+      },
+      semantic: null,
+    },
+    exitCode: outcome?.exitCode === 1 ? 1 : 2,
+  };
+}
+
+export function profileApplySucceeded(
+  outcome: ProjectProfileApplyCommandOutcome | null
+): boolean {
+  if (
+    outcome?.exitCode !== 0 ||
+    (outcome.result.status !== "applied" &&
+      outcome.result.status !== "unchanged")
+  ) {
+    return false;
+  }
+  const receipt = outcome.result.receipt;
+  if (
+    !isProjectProfileApplyReceipt(receipt) ||
+    receipt.status !== outcome.result.status ||
+    outcome.result.applied !== (outcome.result.status === "applied")
+  ) {
+    return false;
+  }
+  const collectionResources = receipt.resources.filter(
+    (resource) => resource.kind === "collection"
+  );
+  return (
+    collectionResources.length === 1 &&
+    Boolean(collectionResources[0]?.id.trim())
+  );
+}
+
+export async function inspectSetupProfile(
+  options: SetupProfileIntegrationOptions
+): Promise<SetupProfileInspectionOutcome> {
+  try {
+    const outcome = await (
+      options.inspectProfileAdvisory ??
+      ((input: SetupProfileAdvisoryInput) =>
+        runProjectProfileCommand({
+          command: "check",
+          cwd: input.folder,
+          configPath: input.configPath,
+          offline: input.offline,
+        }))
+    )({
+      folder: options.folder,
+      configPath: options.configPath,
+      offline: options.offline,
+    });
+    options.onProfileAdvisory?.(outcome.result);
+    return { result: outcome.result, failed: false };
+  } catch {
+    return { result: null, failed: true };
+  }
+}
+
+export async function applySetupProfile(
+  options: SetupProfileIntegrationOptions,
+  inspection: ProjectProfileCommandResult | null
+): Promise<ProjectProfileApplyCommandOutcome | null> {
+  if (!options.applyProfile || inspection?.status !== "valid") return null;
+  try {
+    const outcome = await (
+      options.applyProfileAdvisory ??
+      ((input: SetupProfileAdvisoryInput) =>
+        import("./profile-apply").then(({ runProjectProfileApplyCommand }) =>
+          runProjectProfileApplyCommand({
+            cwd: input.folder,
+            configPath: input.configPath,
+            indexName: options.indexName,
+          })
+        ))
+    )({
+      folder: options.folder,
+      configPath: options.configPath,
+      offline: options.offline,
+    });
+    options.onProfileApply?.(outcome.result);
+    return outcome;
+  } catch {
+    return null;
+  }
+}
+
+export async function setupOptionsAfterProfileApply(
+  options: SetupCommandOptions,
+  applied: ProjectProfileApplyCommandResult | null
+): Promise<SetupCommandOptions | null> {
+  if (
+    !applied ||
+    (applied.status !== "applied" && applied.status !== "unchanged")
+  ) {
+    return options;
+  }
+  const collectionName = applied?.receipt?.resources.find(
+    (resource) => resource.kind === "collection"
+  )?.id;
+  if (!collectionName) return null;
+  const loaded = await loadConfig(options.configPath);
+  const collection = loaded.ok
+    ? loaded.value.collections.find((item) => item.name === collectionName)
+    : undefined;
+  if (!collection) return null;
+  return {
+    ...options,
+    folder: collection.path,
+    name: options.name ?? collection.name,
+    exclude: options.exclude,
+    additiveStoreProjection: true,
+  };
+}
+
+export function formatSetupProfileAdvisory(
+  result: ProjectProfileCommandResult,
+  options: { applyRequested?: boolean } = {}
+): string {
+  if (result.status === "not_found" || result.status === "disabled") return "";
+  if (result.status === "valid" && result.profile) {
+    return [
+      `setup: project profile valid (${result.discovery.profile}; fingerprint=${result.profile.fingerprint})`,
+      "setup: preview profile changes with `gno profile diff`",
+      options.applyRequested
+        ? "setup: applying the profile before lexical setup"
+        : "setup: rerun with `--apply-profile` to apply it before lexical setup",
+    ].join("\n");
+  }
+  const firstError = result.diagnostics.find(
+    (diagnostic) => diagnostic.severity === "error"
+  );
+  return [
+    `setup: project profile ${result.status}; continuing without applying it`,
+    firstError
+      ? `setup: ${firstError.code}: ${firstError.message}`
+      : "setup: run `gno profile check` for repair guidance",
+  ].join("\n");
+}

package/src/cli/commands/setup.ts

@@ -65,6 +65,8 @@ export interface SetupCommandOptions {
   yes?: boolean;
   json?: boolean;
   quiet?: boolean;
+  /** Internal composition flag used after an additive project-profile apply. */
+  additiveStoreProjection?: boolean;
   stdinIsTTY?: boolean;
   stderrIsTTY?: boolean;
   progress?: (stage: SetupStageName, receipt: FolderSetupReceipt) => void;
@@ -297,6 +299,7 @@ async function executeSetup(
       name: options.name,
       exclude: options.exclude,
       secretRiskAuthorized: authorized,
+      additiveStoreProjection: options.additiveStoreProjection,
       receiptWriter,
     });