@@ -0,0 +1,114 @@
+import {
+  MissingParameter,
+  MissingParameterPrompt,
+  MissingParametersResult,
+  ResourceMissingParameters,
+} from '../entities/missing-parameter.js';
+import { ResourceConfig } from '../entities/resource-config.js';
+import { Reporter } from '../ui/reporters/reporter.js';
+import { coerceParameterValue, formatParameterPath, setValueAtPath } from '../utils/missing-parameters.js';
+import { InitializationResult } from './initialize-plugins.js';
+
+/**
+ * Prompts the user for values that are still needed before planning: required keys that are missing and values set to
+ * the dashboard placeholder ('<Replace me here!>'). Answers are applied to the in-memory project only. They are never
+ * written back to the config file.
+ *
+ * Must run after plugins are initialized (resource schemas are needed) and before validation.
+ */
+export const MissingParametersResolver = {
+  async run(initializationResult: InitializationResult, reporter: Reporter): Promise<void> {
+    const { project, pluginManager, resourceDefinitions } = initializationResult;
+
+    // Unknown types are reported by validation
+    const types = [...new Set(project.resourceConfigs.map((r) => r.type))].filter((t) => resourceDefinitions.has(t));
+    const resourceInfoMap = new Map(
+      (await pluginManager.getMultipleResourceInfo(types)).map((info) => [info.type, info])
+    );
+
+    const requests: ResourceMissingParameters[] = [];
+    for (const resource of project.resourceConfigs) {
+      const resourceInfo = resourceInfoMap.get(resource.type);
+      if (!resourceInfo) {
+        continue;
+      }
+
+      const missing = await MissingParametersResolver.resolveChoices(
+        resourceInfo.findMissingParameters(resource),
+        resource,
+        reporter,
+      );
+
+      // Values known from the schema (ex: discriminators of the chosen option) are filled without asking
+      for (const parameter of missing.filter((p) => p.knownValue !== undefined)) {
+        MissingParametersResolver.setParameter(resource, parameter, parameter.knownValue);
+      }
+
+      const sensitiveParameters = resourceDefinitions.get(resource.type)?.sensitiveParameters ?? [];
+      const prompts: MissingParameterPrompt[] = missing
+        .filter((p) => p.knownValue === undefined)
+        .map((p) => ({
+          ...p,
+          label: formatParameterPath(p.path),
+          sensitive: sensitiveParameters.includes('*') || sensitiveParameters.includes(String(p.path[0])),
+        }));
+
+      if (prompts.length > 0) {
+        requests.push({ resource, parameters: prompts });
+      }
+    }
+
+    if (requests.length === 0) {
+      return;
+    }
+
+    const answers = await reporter.promptMissingParameters(requests);
+    for (const [idx, { resource, parameters }] of requests.entries()) {
+      for (const [parameterIdx, parameter] of parameters.entries()) {
+        const value = coerceParameterValue(answers[idx]?.[parameterIdx], parameter.type, parameter.itemsType);
+        MissingParametersResolver.setParameter(resource, parameter, value);
+      }
+    }
+  },
+
+  /**
+   * Flattens the result into a list of parameters. Where the schema allows multiple options (oneOf / anyOf) the user is
+   * asked to pick one first.
+   */
+  async resolveChoices(
+    result: MissingParametersResult,
+    resource: ResourceConfig,
+    reporter: Reporter,
+  ): Promise<MissingParameter[]> {
+    const parameters = [...result.parameters];
+
+    for (const choice of result.choices) {
+      const location = choice.path.length > 0 ? ` at "${formatParameterPath(choice.path)}"` : '';
+      const selected = await reporter.promptOptions(
+        `Resource "${resource.id}" requires one of the following options${location}. Which one would you like to configure?`,
+        choice.options.map((o) => o.label),
+      );
+
+      const option = choice.options[selected];
+      if (!option) {
+        throw new Error(`Invalid option selected for resource "${resource.id}"`);
+      }
+
+      parameters.push(...await MissingParametersResolver.resolveChoices(option.result, resource, reporter));
+    }
+
+    // The same value can be reported by more than one branch of a schema
+    const seen = new Set<string>();
+    return parameters.filter((p) => {
+      const key = JSON.stringify(p.path);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  },
+
+  setParameter(resource: ResourceConfig, parameter: MissingParameter, value: unknown): void {
+    const [key, ...rest] = parameter.path;
+    resource.setParameter(String(key), setValueAtPath(resource.parameters[key], rest, value));
+  },
+};
@@ -0,0 +1,59 @@
+import { ResourceConfig } from './resource-config.js';
+
+/**
+ * The placeholder value the Codify dashboard writes into configs for values the user still needs to fill in.
+ */
+export const PLACEHOLDER_VALUE = '<Replace me here!>';
+
+/** Location of a value inside a resource's parameters. Strings are object keys, numbers are array indices. */
+export type ParameterPath = Array<number | string>;
+
+/**
+ * A single value that must be supplied by the user before the resource can be planned.
+ */
+export interface MissingParameter {
+  /** Path from the root of the resource's parameters. Ex: ['hosts', 0, 'HostName'] */
+  path: ParameterPath;
+  /** 'missing' if the key is absent but required by the schema. 'placeholder' if the value is {@link PLACEHOLDER_VALUE} */
+  reason: 'missing' | 'placeholder';
+  /** JSON schema type of the value (if known). Used to convert the user's input. */
+  type?: string;
+  /** JSON schema type of the array items (if type is 'array'). */
+  itemsType?: string;
+  description?: string;
+  /** Set when the value is known without asking the user (a schema const, ex: a discriminator). It is filled automatically. */
+  knownValue?: unknown;
+}
+
+/**
+ * Raised when a schema contains a oneOf / anyOf where multiple branches are equally valid. Ex: git-repository
+ * requires either 'directory' or 'parentDirectory'. The user must pick one of the options before values can be prompted.
+ */
+export interface MissingParameterChoice {
+  /** Path to the object the choice applies to */
+  path: ParameterPath;
+  options: Array<{ label: string; result: MissingParametersResult }>;
+}
+
+export interface MissingParametersResult {
+  parameters: MissingParameter[];
+  choices: MissingParameterChoice[];
+}
+
+/**
+ * A missing parameter that is ready to be shown to the user.
+ */
+export interface MissingParameterPrompt extends MissingParameter {
+  /** Human readable path. Ex: hosts[0].HostName */
+  label: string;
+  /** Input should be masked */
+  sensitive: boolean;
+}
+
+/**
+ * All of the values that need to be prompted for a single resource. Passed to {@link Reporter.promptMissingParameters}.
+ */
+export interface ResourceMissingParameters {
+  resource: ResourceConfig;
+  parameters: MissingParameterPrompt[];
+}
@@ -1,5 +1,7 @@
 import { GetResourceInfoResponseData } from '@codifycli/schemas';
 
+import { findMissingParameters } from '../utils/missing-parameters.js';
+import { MissingParametersResult } from './missing-parameter.js';
 import { ResourceConfig } from './resource-config.js';
 
 interface ParameterInfo {
@@ -50,6 +52,14 @@ export class ResourceInfo implements GetResourceInfoResponseData {
     })
   }
 
+  /**
+   * Values the resource still needs before it can be planned: required keys (per the schema) that are missing and
+   * values set to the dashboard placeholder.
+   */
+  findMissingParameters(resource: ResourceConfig): MissingParametersResult {
+    return findMissingParameters(this.schema, resource.parameters);
+  }
+
   getParameterInfo(): ParameterInfo[] {
     if (!this.parametersCache) {
       const { schema } = this;
 
@@ -1,6 +1,7 @@
 import { Config } from '@codifycli/schemas';
 
 import { PluginInitOrchestrator } from '../common/initialize-plugins.js';
+import { MissingParametersResolver } from '../common/resolve-missing-parameters.js';
 import { Plan } from '../entities/plan.js';
 import { Project } from '../entities/project.js';
 import { ProcessName, SubProcessName, ctx } from '../events/context.js';
@@ -36,6 +37,8 @@ export class PlanOrchestrator {
 
     await createStartupShellScriptsIfNotExists();
 
+    // Prompt for missing required values and dashboard placeholders. Must happen before validation.
+    await MissingParametersResolver.run(initializationResult, reporter);
     await ValidateOrchestrator.run({ existing: initializationResult, noProgress: args.noProgress }, reporter);
     project.resolveDependenciesAndCalculateEvalOrder(resourceDefinitions);
     if (OsUtils.isMacOS()) {
 
@@ -7,6 +7,7 @@ import path from 'node:path';
 import semver from 'semver';
 
 import { PluginInitOrchestrator } from '../common/initialize-plugins.js';
+import { MissingParametersResolver } from '../common/resolve-missing-parameters.js';
 import { ProcessName, SubProcessName, ctx } from '../events/context.js';
 import { Reporter } from '../ui/reporters/reporter.js';
 import { StubReporter } from '../ui/reporters/stub-reporter.js';
@@ -36,6 +37,7 @@ export const TestOrchestrator = {
     ctx.subprocessStarted(SubProcessName.TEST_INITIALIZE_AND_VALIDATE);
     // Perform validation initially to ensure the project is valid
     const initializationResult = await PluginInitOrchestrator.run({ ...args, noProgress: true }, reporter);
+    await MissingParametersResolver.run(initializationResult, reporter);
     await ValidateOrchestrator.run({ existing: initializationResult, noProgress: true }, reporter);
     ctx.subprocessFinished(SubProcessName.TEST_INITIALIZE_AND_VALIDATE);
 
 
@@ -1,4 +1,4 @@
-import { FormProps, FormReturnValue } from '@codifycli/ink-form';
+import { FormField, FormProps, FormReturnValue } from '@codifycli/ink-form';
 import { CommandRequestData } from '@codifycli/schemas';
 import cliCursor from 'cli-cursor';
 import { render } from 'ink';
@@ -8,6 +8,7 @@ import stripAnsi from 'strip-ansi'
 
 import { PluginError } from '../../common/errors.js';
 import { ApplyResult } from '../../entities/apply-result.js';
+import { MissingParameterPrompt, ResourceMissingParameters } from '../../entities/missing-parameter.js';
 import { Plan, ResourcePlan } from '../../entities/plan.js';
 import { ResourceConfig } from '../../entities/resource-config.js';
 import { ResourceInfo } from '../../entities/resource-info.js';
@@ -171,7 +172,7 @@ export class DefaultReporter implements Reporter {
       return [];
     }
 
-    fullscreen()
+    enterFullScreen()
     process.on('beforeExit', exitFullScreen);
 
     let props;
@@ -225,16 +226,46 @@ export class DefaultReporter implements Reporter {
       core: { type: v.section.title },
       parameters: v.value,
     }))
+  }
 
-    function fullscreen() {
-      process.stdout.write('\u001B[?1049h');
-      process.stdout.write('\u001B[?1000h');
+  async promptMissingParameters(requests: ResourceMissingParameters[]): Promise<unknown[][]> {
+    if (requests.length === 0) {
+      return [];
     }
 
-    function exitFullScreen() {
-      process.stdout.write('\u001B[?1049l');
-      process.stdout.write('\u001B[?1000l');
+    const prevRenderState = this.getRenderState();
+    const fieldName = (resourceIdx: number, parameterIdx: number) => `r${resourceIdx}_p${parameterIdx}`;
+
+    const formProps: FormProps = {
+      form: {
+        title: 'Missing values: fill out the values below to continue',
+        description: 'These values are only used for this run. They will not be saved to your config.',
+        sections: requests.map(({ resource, parameters }, resourceIdx) => ({
+          title: resource.id,
+          description: resource.resourceInfo?.description,
+          fields: parameters.map((parameter, parameterIdx) => toMissingParameterFormField(parameter, fieldName(resourceIdx, parameterIdx))),
+        })),
+      },
     }
+
+    enterFullScreen();
+    process.on('beforeExit', exitFullScreen);
+
+    const userInput = await this.updateStateAndAwaitEvent<FormReturnValue>(() =>
+      this.updateRenderState(RenderStatus.IMPORT_PROMPT, formProps),
+      RenderEvent.PROMPT_IMPORT_PARAMETERS_RESULT
+    );
+
+    exitFullScreen();
+    process.off('beforeExit', exitFullScreen);
+
+    await this.updateRenderState(prevRenderState.status, prevRenderState.data);
+
+    // Field names are unique across sections so all of the values can be merged together
+    const values: Record<string, unknown> = Object.assign({}, ...userInput.map((section) => section.value));
+    return requests.map(({ parameters }, resourceIdx) =>
+      parameters.map((_, parameterIdx) => values[fieldName(resourceIdx, parameterIdx)])
+    );
   }
 
   async displayImportResult(importResult: ImportResult, showConfigs: boolean): Promise<void> {
@@ -476,3 +507,50 @@ export class DefaultReporter implements Reporter {
     });
   }
 }
+
+function enterFullScreen() {
+  process.stdout.write('\u001B[?1049h');
+  process.stdout.write('\u001B[?1000h');
+}
+
+function exitFullScreen() {
+  process.stdout.write('\u001B[?1049l');
+  process.stdout.write('\u001B[?1000l');
+}
+
+/** Values are returned as typed by the form. They are converted to the schema type by the MissingParametersResolver. */
+function toMissingParameterFormField(parameter: MissingParameterPrompt, name: string): FormField {
+  const base = { name, label: parameter.label, description: parameter.description, required: true };
+
+  if (parameter.sensitive) {
+    return { ...base, type: 'string', mask: '*' };
+  }
+
+  switch (parameter.type) {
+    case 'integer': {
+      return { ...base, type: 'integer' };
+    }
+
+    case 'number': {
+      return { ...base, type: 'float' };
+    }
+
+    case 'boolean': {
+      return { ...base, type: 'boolean', initialValue: false };
+    }
+
+    case 'array': {
+      return ['integer', 'number', 'string', undefined].includes(parameter.itemsType)
+        ? { ...base, type: 'array' }
+        : { ...base, type: 'string', description: `${parameter.description ?? ''} (JSON array)`.trim() };
+    }
+
+    case 'object': {
+      return { ...base, type: 'string', description: `${parameter.description ?? ''} (JSON object)`.trim() };
+    }
+
+    default: {
+      return { ...base, type: 'string' };
+    }
+  }
+}
@@ -2,6 +2,7 @@ import { CommandRequestData } from '@codifycli/schemas';
 
 import { PluginError } from '../../common/errors.js';
 import { ApplyResult } from '../../entities/apply-result.js';
+import { ResourceMissingParameters } from '../../entities/missing-parameter.js';
 import { Plan } from '../../entities/plan.js';
 import { ResourceConfig } from '../../entities/resource-config.js';
 import { ImportResult } from '../../orchestrators/import.js';
@@ -53,6 +54,11 @@ export class JsonReporter implements Reporter {
     throw new Error('Json reporter error: cannot prompt user for values while using Json reporter. Use a different reporter.');
   }
 
+  async promptMissingParameters(requests: ResourceMissingParameters[]): Promise<unknown[][]> {
+    const missing = requests.flatMap(({ resource, parameters }) => parameters.map((p) => `${resource.id}.${p.label}`));
+    throw new Error(`Json reporter error: the following values are missing from the config and cannot be prompted while using the Json reporter: ${JSON.stringify(missing)}`);
+  }
+
   async displayImportResult(importResult: ImportResult): Promise<void> {
     console.log(JSON.stringify(importResult.result.map((r) => r.raw)));
   }