fjall 0.96.0 → 0.99.1

package/bin/assets/src/util/api/scaffoldNotification.js

@@ -0,0 +1 @@
+import{maskSensitiveOutput as a}from"@fjall/util";import{getErrorMessage as e}from"../errorUtils.js";import{logger as i}from"../logger/index.js";async function l(){try{const{FjallApiClient:o}=await import("./FjallApiClient.js"),t=o.fromCredentials();if(!t){i.warn("ScaffoldNotification","Not logged in, skipping scaffold notification");return}i.info("ScaffoldNotification","Notifying scaffold complete",{baseUrl:t.getBaseUrl()});const f=await t.markScaffolded();f.success?i.info("ScaffoldNotification","Scaffold complete notification sent"):i.warn("ScaffoldNotification","Scaffold notification failed",{error:a(e(f.error))})}catch(o){i.warn("ScaffoldNotification","Failed to notify scaffold complete",{error:a(o instanceof Error?o.message:String(o))})}}export{l as notifyScaffoldComplete};

package/bin/assets/src/util/awsCleanup.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Best-effort `AwsContext.destroyInstance()` swallowing any rejection.
+ *
+ * Used in `finally` blocks and signal-cleanup callbacks where a cleanup throw
+ * would replace the in-flight return value or unhandled-rejection-stall the
+ * process. Per `.claude/rules/robustness-standards.md § "Awaits inside finally
+ * must be caught"`.
+ */
+export declare function cleanupAwsContext(): Promise<void>;

package/bin/assets/src/util/awsCleanup.js

@@ -0,0 +1 @@
+import{AwsContext as t}from"../aws/AwsContext.js";import{getErrorMessage as o}from"./errorUtils.js";import{logger as r}from"./logger/index.js";async function c(){await t.destroyInstance().catch(e=>{r.debug("aws-cleanup","AwsContext cleanup failed",{error:o(e)})})}export{c as cleanupAwsContext};

package/bin/assets/src/util/awsTags.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared Fjall tag construction for AWS resources created outside CloudFormation.
+ *
+ * Both SecretsService (SSM) and SecretManagerService (Secrets Manager) apply
+ * the same core tag set. This helper prevents drift between the two.
+ *
+ * See: aiDocs/patterns/tagging-strategy.md
+ */
+export interface FjallTag {
+    Key: string;
+    Value: string;
+}
+/**
+ * Build the core Fjall tags applied to all CLI-managed secrets.
+ *
+ * Returns: fjall:managed, fjall:application, fjall:costAllocation:service,
+ * and fjall:costAllocation:environment (when environment is resolvable).
+ */
+export declare function buildCoreFjallTags(appName: string, environment: string | undefined): FjallTag[];

package/bin/assets/src/util/awsTags.js

@@ -0,0 +1 @@
+function e(l,a){return[{Key:"fjall:managed",Value:"true"},{Key:"fjall:application",Value:l},{Key:"fjall:costAllocation:service",Value:l},...a?[{Key:"fjall:costAllocation:environment",Value:a}]:[]]}export{e as buildCoreFjallTags};

package/bin/assets/src/util/buildxEventAdapter.d.ts

@@ -0,0 +1,20 @@
+import type { BuildxProgressEvent } from "@fjall/util/docker";
+import type { ResourceEvent } from "../aws/utils/cloudformationEvents.js";
+/**
+ * Project a BuildxProgressEvent onto a ResourceEvent shape consumable by
+ * useParallelOperations.addEvent(stack, event).
+ *
+ * Pure given a fixed clock — no env reads, no logger calls, no closure state.
+ * The orchestrator owns the clock (production: () => new Date()); tests pass
+ * a deterministic stub.
+ *
+ * Per-event status projection:
+ *   vertex / log / status / warning → "running"
+ * Terminal transitions ("complete" / "failed") are emitted by the orchestrator
+ * directly via useParallelOperations.updateStatus, NOT by this adapter — the
+ * adapter only emits per-event projections.
+ *
+ * The event message has already been masked at the DockerCli boundary (PR 0);
+ * this adapter does NOT re-mask.
+ */
+export declare function mapBuildxEventToResourceEvent(serviceName: string, event: BuildxProgressEvent, clock: () => Date): ResourceEvent;

package/bin/assets/src/util/buildxEventAdapter.js

@@ -0,0 +1 @@
+function u(t,e,s){return{logicalId:t,resourceType:e.type,status:a(e),timestamp:s(),...e.message!==""?{statusReason:e.message}:{}}}function a(t){switch(t.type){case"vertex":case"log":case"status":case"warning":return"running";default:return t.type}}export{u as mapBuildxEventToResourceEvent};

package/bin/assets/src/util/caseConversion.d.ts

@@ -0,0 +1 @@
+export { toPascalCase, toKebab, capitalise } from "@fjall/util";

package/bin/assets/src/util/caseConversion.js

@@ -0,0 +1 @@
+import{toPascalCase as o,toKebab as t,capitalise as s}from"@fjall/util";export{s as capitalise,t as toKebab,o as toPascalCase};

package/bin/assets/src/util/codemod/emitCliTelemetry.d.ts

@@ -0,0 +1,32 @@
+import type { CodemodErrorKind } from "@fjall/generator/codemod";
+/**
+ * Write-path codemod operations that contribute to the telemetry
+ * denominator. Read-only operations (list/validate/history) do NOT emit.
+ */
+export type CodemodOp = "add" | "remove" | "modify";
+/**
+ * PII-minimised telemetry envelope for codemod CLI events.
+ *
+ * The type deliberately omits `message`, `path`, `name`, `content`,
+ * `properties`, and `filePath` so the compiler rejects any attempt to
+ * leak user-value strings through this boundary.
+ */
+export interface CliTelemetryEvent {
+    event: `codemod.${CodemodOp}.${"started" | "completed" | "failed"}`;
+    organisationId: string | null;
+    operation: CodemodOp;
+    statementType: string | null;
+    durationMs: number | null;
+    errorKind: CodemodErrorKind | null;
+    interactive: boolean;
+}
+/**
+ * Fire-and-forget telemetry emitter for the codemod CLI surface.
+ *
+ * Posts a PostHog-compatible envelope to the webapp's cli-telemetry
+ * ingress route with a 2-second timeout. Every transport error is
+ * caught at `logger.debug` — the helper NEVER throws.
+ *
+ * Kill-switch: `FJALL_CLI_TELEMETRY=off` short-circuits at entry.
+ */
+export declare function emitCliTelemetry(event: CliTelemetryEvent): Promise<void>;

package/bin/assets/src/util/codemod/emitCliTelemetry.js

@@ -0,0 +1 @@
+import E from"axios";import{resolveApiKey as f}from"../api/resolveApiKey.js";import{DEFAULT_BASE_URL as y,USER_AGENT as g}from"../api/FjallApiClient.types.js";import{logger as n}from"../logger/index.js";const i="CliTelemetry",u="/api/cli-telemetry",d=2e3;async function v(s){if(process.env.FJALL_CLI_TELEMETRY==="off")return;const o=f();if(!o){n.debug(i,"Skipping telemetry \u2014 no API key resolved");return}const l=`${y}${u}`,{event:a,...c}=s,m={event:a,properties:c},p={"Content-Type":"application/json","User-Agent":g,Authorization:`Bearer ${o}`},r=new AbortController;let e;try{e=setTimeout(()=>r.abort(),d),await E.post(l,m,{headers:p,signal:r.signal})}catch(t){const T=t instanceof Error?t.message:String(t);n.debug(i,`Telemetry post failed: ${T}`)}finally{e!==void 0&&clearTimeout(e)}}export{v as emitCliTelemetry};

package/bin/assets/src/util/codemod/exitCodes.d.ts

@@ -0,0 +1,11 @@
+import type { CodemodError } from "@fjall/generator/codemod";
+import type { CodemodIoError } from "../../operations/codemodHistory.js";
+export declare const CODEMOD_EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly GENERIC_ERROR: 1;
+    readonly USER_ERROR: 2;
+    readonly STATE_CONFLICT: 3;
+    readonly IO_ERROR: 4;
+};
+export type CodemodExitCode = (typeof CODEMOD_EXIT_CODES)[keyof typeof CODEMOD_EXIT_CODES];
+export declare function mapCodemodErrorToExitCode(error: CodemodError | CodemodIoError): CodemodExitCode;

package/bin/assets/src/util/codemod/exitCodes.js

@@ -0,0 +1 @@
+const r={SUCCESS:0,GENERIC_ERROR:1,USER_ERROR:2,STATE_CONFLICT:3,IO_ERROR:4};function o(e){switch(e.kind){case"ParseError":case"TemplateLiteralNameError":case"ResourceNotFoundError":case"InvalidPropertyError":case"PermissionError":return r.USER_ERROR;case"DuplicateResourceError":case"ReferencesRemainError":case"DriftConflictError":case"DriftUnmergeableError":return r.STATE_CONFLICT;case"ControlFlowClassifierError":case"LlmFallbackRejectedError":case"LlmFallbackUnsafeInputError":return r.USER_ERROR;case"LlmFallbackTimeoutError":return r.STATE_CONFLICT;case"SemanticQueryError":return r.GENERIC_ERROR;case"IoError":case"NotFoundError":case"InvalidSnapshotError":return r.IO_ERROR;default:{const E=e;return r.GENERIC_ERROR}}}export{r as CODEMOD_EXIT_CODES,o as mapCodemodErrorToExitCode};

package/bin/assets/src/util/codemod/index.d.ts

@@ -0,0 +1,3 @@
+export { CODEMOD_EXIT_CODES, mapCodemodErrorToExitCode, type CodemodExitCode } from "./exitCodes.js";
+export { renderCodemodError, renderCodemodSuccess } from "./renderCodemod.js";
+export { CODEMOD_STEP_LABELS, type CodemodOp } from "./stepLabels.js";

package/bin/assets/src/util/codemod/index.js

@@ -0,0 +1 @@
+import{CODEMOD_EXIT_CODES as e,mapCodemodErrorToExitCode as d}from"./exitCodes.js";import{renderCodemodError as m,renderCodemodSuccess as C}from"./renderCodemod.js";import{CODEMOD_STEP_LABELS as O}from"./stepLabels.js";export{e as CODEMOD_EXIT_CODES,O as CODEMOD_STEP_LABELS,d as mapCodemodErrorToExitCode,m as renderCodemodError,C as renderCodemodSuccess};

package/bin/assets/src/util/codemod/renderCodemod.d.ts

@@ -0,0 +1,5 @@
+import type { CodemodError, CodemodSuccess } from "@fjall/generator/codemod";
+import type { CodemodIoError } from "../../operations/codemodHistory.js";
+import type { OutputWriter } from "../nonInteractive/nonInteractiveOutput.js";
+export declare function renderCodemodSuccess(writer: OutputWriter, op: "add" | "remove" | "modify", filePath: string, data: CodemodSuccess): void;
+export declare function renderCodemodError(writer: OutputWriter, error: CodemodError | CodemodIoError): void;

package/bin/assets/src/util/codemod/renderCodemod.js

@@ -0,0 +1 @@
+import{maskSensitiveOutput as d}from"@fjall/util";import{formatDuration as u}from"../formatDuration.js";const a=(n,e)=>{n.indent(d(e))};function l(n,e,t,c){const{linesChanged:s,references:o}=c,i=s.added===0&&s.removed===0?"no-op (already at target state)":`+${String(s.added)}/-${String(s.removed)}`;n.indent(`${e} succeeded: ${i} in ${t}`),e==="remove"&&o!==void 0&&n.indent(o.length===0?"No remaining references to the removed resource.":`${String(o.length)} remaining reference${o.length===1?"":"s"} (use --force to override).`)}function $(n,e){switch(e.kind){case"ParseError":a(n,`Parse error: ${e.message||"unrecoverable syntax in target file"}`);return;case"TemplateLiteralNameError":a(n,`Template-literal name not supported. ${e.suggestion}`);return;case"DuplicateResourceError":a(n,`Resource '${e.name}' (${e.type}) already exists \u2014 choose a different name.`);return;case"ResourceNotFoundError":a(n,`Resource not found: ${e.name} (${e.type}).`);return;case"ReferencesRemainError":a(n,`Cannot remove '${e.variable}' \u2014 ${String(e.references.length)} reference${e.references.length===1?"":"s"} remain. Use --force to override.`);return;case"InvalidPropertyError":a(n,`Invalid property ${e.property}: ${e.reason}`);return;case"SemanticQueryError":a(n,`Semantic analysis failed: ${e.reason}`);return;case"PermissionError":{const t=e.remediation!==void 0?` ${e.remediation}`:"";a(n,`Permission error (${e.reason}): ${e.details}.${t}`);return}case"IoError":a(n,`I/O error during ${e.operation} on ${e.path}: ${e.cause instanceof Error?e.cause.message:String(e.cause)}`);return;case"NotFoundError":a(n,`Not found: ${e.path}`);return;case"InvalidSnapshotError":a(n,`Invalid snapshot ${e.path}: ${e.reason}`);return;case"DriftConflictError":{const t=e.deltas.filter(s=>s.verdict==="conflict").map(s=>s.property),c=e.remediation!==void 0?` ${e.remediation}`:"";a(n,`Drift conflict on ${e.resource.type} '${e.resource.name}': conflicting properties [${t.join(", ")}].${c}`);return}case"DriftUnmergeableError":a(n,`Cannot merge drift on ${e.resource.type} '${e.resource.name}': ${e.reason}`);return;case"ControlFlowClassifierError":{const t=e.remediation!==void 0?` ${e.remediation}`:"";a(n,`Operation refused (${e.reason}): ${e.resource.type} '${e.resource.name}'.${t}`);return}case"LlmFallbackRejectedError":a(n,`LLM fallback (${e.tier}) rejected at gate "${e.failedGate}": ${e.diagnostics}`);return;case"LlmFallbackTimeoutError":a(n,`LLM fallback (${e.tier}) timed out after ${u(e.elapsedMs)}.`);return;case"LlmFallbackUnsafeInputError":a(n,`LLM fallback blocked: ${String(e.count)} ${e.reason} match(es) detected in input.`);return;default:{const t=e;a(n,"Unknown codemod error.")}}}export{$ as renderCodemodError,l as renderCodemodSuccess};

package/bin/assets/src/util/codemod/stepLabels.d.ts

@@ -0,0 +1,11 @@
+export declare const CODEMOD_STEP_LABELS: {
+    readonly add: readonly ["Locating", "Inserting", "Validating", "Writing"];
+    readonly remove: readonly ["Locating", "Removing", "Validating", "Writing"];
+    readonly modify: readonly ["Locating", "Modifying", "Validating", "Writing"];
+    readonly validate: readonly ["Validating"];
+    readonly undo: readonly ["Restoring"];
+    readonly list: readonly ["Listing"];
+    readonly history: readonly ["Listing"];
+    readonly "history-restore": readonly ["Restoring"];
+};
+export type CodemodOp = keyof typeof CODEMOD_STEP_LABELS;

package/bin/assets/src/util/codemod/stepLabels.js

@@ -0,0 +1 @@
+const i={add:["Locating","Inserting","Validating","Writing"],remove:["Locating","Removing","Validating","Writing"],modify:["Locating","Modifying","Validating","Writing"],validate:["Validating"],undo:["Restoring"],list:["Listing"],history:["Listing"],"history-restore":["Restoring"]};export{i as CODEMOD_STEP_LABELS};

package/bin/assets/src/util/colourUtils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Colour manipulation utilities for terminal rendering.
+ * Supports hex (#RRGGBB) and rgb(r,g,b) formats.
+ */
+export interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+/** Parse a hex colour (#RRGGBB) or rgb(r,g,b) string to RGB components */
+export declare function parseColour(colour: string): RGB | undefined;
+/** Convert RGB components to a hex colour string */
+export declare function toHex(rgb: RGB): `#${string}`;
+/**
+ * Linearly interpolate between two colours.
+ * @param from - Start colour
+ * @param to - End colour
+ * @param t - Interpolation factor (0 = from, 1 = to)
+ * @returns Interpolated colour as hex string
+ */
+export declare function interpolateColour(from: RGB, to: RGB, t: number): `#${string}`;

package/bin/assets/src/util/colourUtils.js

@@ -0,0 +1 @@
+function i(t){if(t.startsWith("#")&&t.length===7){const r=parseInt(t.slice(1,3),16),a=parseInt(t.slice(3,5),16),e=parseInt(t.slice(5,7),16);if(!Number.isNaN(r)&&!Number.isNaN(a)&&!Number.isNaN(e))return{r,g:a,b:e}}const n=t.match(/^rgb\((\d+),(\d+),(\d+)\)$/);if(n)return{r:parseInt(n[1]??"0",10),g:parseInt(n[2]??"0",10),b:parseInt(n[3]??"0",10)}}function s(t){const n=Math.max(0,Math.min(255,Math.round(t.r))),r=Math.max(0,Math.min(255,Math.round(t.g))),a=Math.max(0,Math.min(255,Math.round(t.b)));return`#${n.toString(16).padStart(2,"0")}${r.toString(16).padStart(2,"0")}${a.toString(16).padStart(2,"0")}`}function h(t,n,r){const a=Math.max(0,Math.min(1,r));return s({r:t.r+(n.r-t.r)*a,g:t.g+(n.g-t.g)*a,b:t.b+(n.b-t.b)*a})}export{h as interpolateColour,i as parseColour,s as toHex};

package/bin/assets/src/util/commandErrorHandler.d.ts

@@ -0,0 +1,16 @@
+export type CommandInfo = {
+    name: string;
+    description: string;
+};
+/**
+ * Registers an error handler for unknown commands on a commander command object
+ *
+ * @param command The commander command object to register the handler on
+ * @param commandType 'command' for top-level commands, 'subcommand' for subcommands
+ * @param commands List of available commands with names and descriptions
+ * @param parentCommand Optional name of the parent command for subcommands
+ */
+export declare function registerUnknownCommandHandler(command: {
+    on: (event: string | symbol, handler: (...args: unknown[]) => void) => unknown;
+    outputHelp: () => void;
+}, commandType: "command" | "subcommand", _commands: CommandInfo[], _parentCommand?: string): void;

package/bin/assets/src/util/commandErrorHandler.js

@@ -0,0 +1 @@
+import{error as t}from"./log.js";function d(n,o,m,p){n.on("command:*",function(...r){const e=r[0];t(`Unknown ${o}: ${e[0]}`),n.outputHelp(),process.exitCode=1})}export{d as registerUnknownCommandHandler};

package/bin/assets/src/util/commandResult.d.ts

@@ -0,0 +1,63 @@
+import type { Result } from "../types/Result.js";
+import type { ProgressEvent, ProgressCallbacks } from "../types/ProgressEvent.js";
+import type { OutputWriter } from "./nonInteractive/nonInteractiveOutput.js";
+/**
+ * Sentinel error for cases where the error has already been displayed.
+ * The top-level handler in cli.ts exits with code 1 without printing the message again.
+ */
+export declare class SilentExitError extends Error {
+    constructor();
+}
+export interface CommandResult {
+    success?: boolean;
+    message?: string;
+    cancelled?: boolean;
+    error?: Error | string;
+    finalState?: unknown;
+}
+export declare function handleUIResult(result: CommandResult | undefined): void;
+export declare function handleServiceResult(result: CommandResult): void;
+export declare function throwOnFailure<T>(result: Result<T, unknown>): asserts result is {
+    success: true;
+    data: T;
+};
+/**
+ * Context passed by command handlers to `handleCommandError` for agent-mode
+ * suggestion resolution. Optional — existing non-agent callers pass nothing
+ * and behaviour is unchanged.
+ */
+export interface CommandErrorContext {
+    readonly command?: string;
+    readonly flags?: Readonly<Record<string, string>>;
+}
+/**
+ * Unified command-error handler. In standard CLI mode this simply re-throws
+ * so the top-level handler can format and print to stderr. In agent mode it
+ * emits a structured TOON error block to stdout and exits with the mapped
+ * code — bypassing the stderr path entirely.
+ *
+ * Masking happens inline here because the agent error path bypasses the
+ * `AgentOutputWriter` callback path. This is the other half of the
+ * "two separate single boundaries" masking policy (see synthesis §1.11).
+ */
+export declare function handleCommandError(error: unknown, context?: CommandErrorContext): never;
+export declare function throwIfInvalidOptions(validation: {
+    success: true;
+} | {
+    success: false;
+    error: {
+        message: string;
+    };
+}): void;
+export declare function requireOption<T>(value: T | undefined | null, name: string, flag: string): asserts value is T;
+export declare function requireArg(value: string | undefined, name: string, usage: string): asserts value is string;
+export declare function throwUnknownSubcommand(subcommand: string, available: string[]): never;
+export declare function createCLIProgressCallback(writer: OutputWriter): (event: ProgressEvent) => void;
+export declare function createProgressHandler(writer: OutputWriter, verbose: boolean): ProgressCallbacks;
+export declare function validateRequiredArgs(args: Record<string, unknown>, required: string[]): void;
+interface ValidationServiceLike {
+    getMissingRequiredFields(command: string, options: Record<string, unknown>): string[];
+    fieldNamesToFlags(fields: string[]): string[];
+}
+export declare function throwIfMissingFields(validationService: ValidationServiceLike, command: string, options: Record<string, unknown>, interactiveModeHint?: string): void;
+export {};

package/bin/assets/src/util/commandResult.js

@@ -0,0 +1 @@
+import{getErrorMessage as l}from"./errorUtils.js";import t from"chalk";import{theme as m}from"./theme.js";import{maskSensitiveOutput as c}from"@fjall/util";import{isAgentMode as p}from"./executionMode.js";import{extractMessage as h,mapErrorToCode as w,isUserActionRequired as E}from"./agent/errorCodes.js";import{renderError as k,renderHelp as x,joinBlocks as b}from"./agent/toonFormatter.js";import{SuggestionResolver as $}from"./agent/suggestions.js";class q extends Error{constructor(){super("Silent exit"),this.name="SilentExitError"}}function B(r){if(!r)throw new Error("UI operation returned no result");if(!r.cancelled&&!r.success)throw r.finalState?new q:new Error(r.message||"UI operation failed")}function P(r){if(!r.success){const e=r.message||(r.error?l(r.error):void 0)||"Operation failed";throw new Error(e)}}function L(r){if(!r.success)throw new Error(l(r.error))}function T(r,e){throw p()&&I(r,e),r}function I(r,e){const o=w(r),n=h(r),i={message:c(n),code:o,userActionRequired:E(o)},f=k(i);let a="";if(e?.command!==void 0&&e.command.length>0){const d=new $(e.command,e.flags??{}).resolve({command:e.command,outcome:"error"});d.length>0&&(a=x(d))}const u=b([f,a]);process.stdout.write(u);const g=M(o);throw process.exit(g),r}function M(r){return r==="VALIDATION_ERROR"?2:1}function y(r){if(!r.success)throw console.error("Error: Invalid options provided:"),console.error(`  ${c(r.error.message)}`),new Error("Invalid options provided")}function D(r,e,o){if(r==null||r==="")throw console.error(`Error: ${e} is required. Use --${o} flag`),new Error(`${e} is required`)}function H(r,e,o){if(!r)throw console.error(`Error: ${e} is required`),console.error(`Usage: ${o}`),new Error(`${e} is required`)}function N(r,e){throw console.error(`Error: Unknown subcommand '${r}'`),console.error(`Available subcommands: ${e.join(", ")}`),new Error(`Unknown subcommand '${r}'`)}function W(r){const e=m.colours;return o=>{const n=c(o.message);switch(o.type){case"step":r.indent(t.hex(e.completed)("\u2713")+" "+n);break;case"warning":r.indent(t.hex(e.warning)("Warning: "+n));break;case"info":r.indent(n,2);break;case"error":r.indent(t.hex(e.error)("Error: "+n));break;case"debug":break}}}function G(r,e){const o=m.colours;return{onProgress:n=>{const s=c(n.message);switch(n.type){case"step":r.indent(s);break;case"info":r.indent(s,2);break;case"spinner":r.indent(`${s}...`,2);break;case"warning":r.indent(`Warning: ${s}`);break;case"error":r.indent(t.hex(o.error)(`Error: ${s}`));break;case"debug":e&&r.indent(`[DEBUG] ${s}`,2);break}}}}function V(r,e){const o=e.filter(n=>r[n]===void 0||r[n]===null);if(o.length>0)throw new Error(`Missing required arguments: ${o.join(", ")}`)}function _(r,e,o,n="omit --non-interactive for interactive mode"){const s=r.getMissingRequiredFields(e,o);if(s.length>0){const i=r.fieldNamesToFlags(s);throw console.error(`Error: Missing required fields: ${i.join(", ")}`),console.error(`Provide all required flags or ${n}`),new Error(`Missing required fields: ${i.join(", ")}`)}}export{q as SilentExitError,W as createCLIProgressCallback,G as createProgressHandler,T as handleCommandError,P as handleServiceResult,B as handleUIResult,H as requireArg,D as requireOption,y as throwIfInvalidOptions,_ as throwIfMissingFields,L as throwOnFailure,N as throwUnknownSubcommand,V as validateRequiredArgs};

package/bin/assets/src/util/concurrency.d.ts

@@ -0,0 +1,35 @@
+import { type Result } from "../types/Result.js";
+export interface RunWithBoundedConcurrencyOptions {
+    /**
+     * When true, stop issuing new jobs after the first failure. The orchestrator
+     * is responsible for owning the AbortController and signalling in-flight jobs;
+     * this runner only propagates the signal to job factories.
+     */
+    abortOnFirstFailure?: boolean;
+    /**
+     * Optional abort signal propagated to every job. Jobs are responsible for
+     * honouring the signal themselves.
+     */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Run a list of async jobs with a bounded number in-flight at any tick.
+ *
+ * Returns results in INPUT order (job N's result lives at index N) regardless
+ * of completion order. When `abortOnFirstFailure` is true, the runner stops
+ * issuing new jobs after the first failure but does NOT cancel in-flight jobs
+ * — the orchestrator owns the AbortController and is responsible for
+ * propagating the signal source.
+ */
+export declare function runWithBoundedConcurrency<T>(jobs: ReadonlyArray<() => Promise<T>>, concurrency: number, opts?: RunWithBoundedConcurrencyOptions): Promise<Array<Result<T, Error>>>;
+/**
+ * Resolve the per-orchestrator-run build concurrency from the
+ * `FJALL_BUILD_CONCURRENCY` environment variable, clamped to `[1, serviceCount]`.
+ *
+ * - Empty-string env values are rejected (per robustness-standards.md
+ *   § "Environment Variable Truthy Checks").
+ * - Non-integer / non-positive values fall back to the default.
+ * - When `serviceCount === 0`, returns `1` (no jobs would be issued anyway).
+ * - The default is CPU-aware (see `defaultBuildConcurrency`).
+ */
+export declare function resolveBuildConcurrency(serviceCount: number): number;

package/bin/assets/src/util/concurrency.js

@@ -0,0 +1 @@
+import p from"os";import{success as y,failure as x}from"../types/Result.js";async function F(r,e,a={}){const t=r.length,i=new Array(t);if(t===0)return i;const l=Math.max(1,Math.min(e,t)),c=a.abortOnFirstFailure===!0;let u=0,s=!1;async function h(){for(;;){if(c&&s)return;const n=u;if(n>=t)return;u=n+1;const d=r[n];try{const o=await d();i[n]=y(o)}catch(o){const m=o instanceof Error?o:new Error(String(o));i[n]=x(m),c&&(s=!0)}}}const f=[];for(let n=0;n<l;n++)f.push(h());return await Promise.all(f),i}function w(r){const e=p.cpus().length;return Math.min(r,Math.max(2,Math.floor(e/2)))}function g(r){if(r<=0)return 1;const e=process.env.FJALL_BUILD_CONCURRENCY;let a=w(r);if(e!==void 0&&e!==""){const t=parseInt(e,10);Number.isInteger(t)&&t>0&&(a=t)}return Math.max(1,Math.min(a,r))}export{g as resolveBuildConcurrency,F as runWithBoundedConcurrency};

package/bin/assets/src/util/deploymentEvents.d.ts

@@ -0,0 +1,155 @@
+import { z } from "zod";
+import type { ResourceEvent } from "@fjall/util/aws";
+import { type ResourceMapEntry } from "@fjall/util/constructMap";
+/**
+ * Deployment event schema for CLI-side event emission.
+ *
+ * The canonical schema lives in @fjall/deploy-core (deploymentEventSchema.ts)
+ * and is used by both the webapp and worker. The CLI maintains its own copy
+ * because deploy-core's schema adds `.max()` length constraints for server-side
+ * input validation — the CLI is the emitter, not the receiver, so those
+ * constraints would incorrectly reject valid CloudFormation resource names and
+ * log messages that exceed the inbound limits.
+ */
+declare const CASCADE_PHASES: readonly ["platform", "domains", "accounts"];
+declare const CASCADE_ACCOUNT_STATUSES: readonly ["started", "deploying", "completed", "failed"];
+export declare const DeploymentProgressEventSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        error: "error";
+        step: "step";
+        complete: "complete";
+        resource: "resource";
+        docker: "docker";
+        ecs: "ecs";
+        cascade_phase: "cascade_phase";
+        cascade_account: "cascade_account";
+        parallel_phase: "parallel_phase";
+        detection: "detection";
+        log: "log";
+    }>;
+    timestamp: z.ZodString;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    step: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        index: z.ZodNumber;
+        total: z.ZodNumber;
+        status: z.ZodString;
+    }, z.core.$strict>>;
+    resource: z.ZodOptional<z.ZodObject<{
+        logicalId: z.ZodString;
+        resourceType: z.ZodString;
+        category: z.ZodEnum<{
+            security: "security";
+            network: "network";
+            compute: "compute";
+            database: "database";
+            storage: "storage";
+            monitoring: "monitoring";
+            dns: "dns";
+            identity: "identity";
+            bootstrap: "bootstrap";
+            events: "events";
+            registry: "registry";
+            backup: "backup";
+        }>;
+        group: z.ZodOptional<z.ZodString>;
+        constructPath: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodString;
+        status: z.ZodString;
+        statusReason: z.ZodOptional<z.ZodString>;
+        physicalId: z.ZodOptional<z.ZodString>;
+        expectedDurationSeconds: z.ZodOptional<z.ZodNumber>;
+        stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    docker: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        percentage: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    ecs: z.ZodOptional<z.ZodObject<{
+        status: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        percentage: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        category: z.ZodOptional<z.ZodString>;
+        remediation: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    message: z.ZodOptional<z.ZodString>;
+    cascadePhase: z.ZodOptional<z.ZodObject<{
+        phase: z.ZodEnum<{
+            platform: "platform";
+            domains: "domains";
+            accounts: "accounts";
+        }>;
+        status: z.ZodEnum<{
+            started: "started";
+            completed: "completed";
+        }>;
+    }, z.core.$strict>>;
+    cascadeAccount: z.ZodOptional<z.ZodObject<{
+        accountId: z.ZodString;
+        region: z.ZodString;
+        operationKey: z.ZodString;
+        status: z.ZodEnum<{
+            started: "started";
+            deploying: "deploying";
+            completed: "completed";
+            failed: "failed";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        phase: z.ZodOptional<z.ZodEnum<{
+            deploy: "deploy";
+            destroy: "destroy";
+            bootstrap: "bootstrap";
+            synth: "synth";
+        }>>;
+        cascadePhase: z.ZodOptional<z.ZodEnum<{
+            platform: "platform";
+            domains: "domains";
+            accounts: "accounts";
+        }>>;
+    }, z.core.$strict>>;
+    parallelPhase: z.ZodOptional<z.ZodObject<{
+        stacks: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            started: "started";
+            completed: "completed";
+        }>;
+        results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            stack: z.ZodString;
+            success: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    detection: z.ZodOptional<z.ZodObject<{
+        pattern: z.ZodNullable<z.ZodString>;
+        hasDockerfile: z.ZodBoolean;
+        hasDifferences: z.ZodBoolean;
+        resources: z.ZodObject<{
+            hasNetwork: z.ZodBoolean;
+            hasCompute: z.ZodBoolean;
+            hasDatabase: z.ZodBoolean;
+            hasStorage: z.ZodBoolean;
+            hasMessaging: z.ZodBoolean;
+            hasCdn: z.ZodBoolean;
+        }, z.core.$strict>;
+        requiredSecrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    log: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        level: z.ZodEnum<{
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type DeploymentProgressEvent = z.infer<typeof DeploymentProgressEventSchema>;
+export type { ResourceCategory } from "@fjall/util";
+export type CascadePhase = (typeof CASCADE_PHASES)[number];
+export type CascadeAccountStatus = (typeof CASCADE_ACCOUNT_STATUSES)[number];
+export { categoriseResource, getExpectedDuration } from "@fjall/util";
+export declare function logEvent(message: string, level?: "info" | "debug" | "warn"): DeploymentProgressEvent;
+export declare function toDeploymentEvent(event: ResourceEvent, constructMap?: Map<string, ResourceMapEntry>): DeploymentProgressEvent;

package/bin/assets/src/util/deploymentEvents.js

@@ -0,0 +1 @@
+import{z as e}from"zod";import{RESOURCE_CATEGORIES as c,categoriseResource as i,getExpectedDuration as p}from"@fjall/util";import{enrichFromConstructMap as l}from"@fjall/util/constructMap";const n=["platform","domains","accounts"],u=["started","deploying","completed","failed"],g=["step","resource","docker","ecs","error","complete","cascade_phase","cascade_account","parallel_phase","detection","log"],d={step:"step",resource:"resource",docker:"docker",ecs:"ecs",error:"error",complete:null,cascade_phase:"cascadePhase",cascade_account:"cascadeAccount",parallel_phase:"parallelPhase",detection:"detection",log:"log"},b=e.object({type:e.enum(g),timestamp:e.string(),sequence:e.number().int().nonnegative().optional(),step:e.object({id:e.string(),name:e.string(),index:e.number(),total:e.number(),status:e.string()}).strict().optional(),resource:e.object({logicalId:e.string(),resourceType:e.string(),category:e.enum(c),group:e.string().min(1).max(128).optional(),constructPath:e.string().min(1).max(512).optional(),displayName:e.string(),status:e.string(),statusReason:e.string().optional(),physicalId:e.string().optional(),expectedDurationSeconds:e.number().optional(),stack:e.string().optional()}).strict().optional(),docker:e.object({message:e.string(),percentage:e.number().optional()}).strict().optional(),ecs:e.object({status:e.string(),message:e.string().optional(),percentage:e.number().optional()}).strict().optional(),error:e.object({message:e.string(),category:e.string().optional(),remediation:e.array(e.string()).optional()}).strict().optional(),message:e.string().optional(),cascadePhase:e.object({phase:e.enum(n),status:e.enum(["started","completed"])}).strict().optional(),cascadeAccount:e.object({accountId:e.string(),region:e.string(),operationKey:e.string(),status:e.enum(u),error:e.string().optional(),phase:e.enum(["bootstrap","synth","deploy","destroy"]).optional(),cascadePhase:e.enum(n).optional()}).strict().optional(),parallelPhase:e.object({stacks:e.array(e.string()),status:e.enum(["started","completed"]),results:e.array(e.object({stack:e.string(),success:e.boolean(),error:e.string().optional()}).strict()).optional()}).strict().optional(),detection:e.object({pattern:e.string().nullable(),hasDockerfile:e.boolean(),hasDifferences:e.boolean(),resources:e.object({hasNetwork:e.boolean(),hasCompute:e.boolean(),hasDatabase:e.boolean(),hasStorage:e.boolean(),hasMessaging:e.boolean(),hasCdn:e.boolean()}).strict(),requiredSecrets:e.array(e.string()).optional()}).strict().optional(),log:e.object({message:e.string(),level:e.enum(["info","debug","warn"])}).strict().optional()}).strict().superRefine((t,s)=>{const o=d[t.type],r=o?t[o]:void 0;o&&r==null&&s.addIssue({code:e.ZodIssueCode.custom,message:`"${o}" is required when type is "${t.type}"`,path:[o]}),t.type==="complete"&&!t.message&&s.addIssue({code:e.ZodIssueCode.custom,message:'"message" is required when type is "complete"',path:["message"]})});import{categoriseResource as D,getExpectedDuration as T}from"@fjall/util";function f(t,s="info"){return{type:"log",timestamp:new Date().toISOString(),log:{message:t,level:s}}}function E(t,s){const o=l(t.logicalId,t.resourceType,s),r=t.group??o.group,a=t.constructPath??o.constructPath;return{type:"resource",timestamp:t.timestamp.toISOString(),resource:{logicalId:t.logicalId,resourceType:t.resourceType,category:i(t.resourceType),...r!==void 0?{group:r}:{},...a!==void 0?{constructPath:a}:{},displayName:o.displayName,status:t.status,statusReason:t.statusReason,physicalId:t.physicalId,expectedDurationSeconds:p(t.resourceType)}}}export{b as DeploymentProgressEventSchema,D as categoriseResource,T as getExpectedDuration,f as logEvent,E as toDeploymentEvent};

package/bin/assets/src/util/errorDisplay.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Display validation error with consistent colour formatting
+ */
+export declare function displayValidationError(validationError: string, expectedPath: string): void;

package/bin/assets/src/util/errorDisplay.js

@@ -0,0 +1,2 @@
+import o from"chalk";import{INFRASTRUCTURE_FILENAME as i}from"./pathHelpers.js";function E(n,e){const r=n.split(`
+`);r[0].includes("does not exist")?console.error(o.hex("#AE2012")("Error: Target folder ")+o.hex("#0A9396")(e)+o.hex("#AE2012")(" does not exist")):r[0].includes(`No ${i}`)?console.error(o.hex("#AE2012")(`Error: No ${i} found in `)+o.hex("#0A9396")(e)):console.error(o.hex("#AE2012")(`Error: ${r[0]}`)),r[1]&&console.error(o.hex("#FFECD1")(r[1]))}export{E as displayValidationError};

package/bin/assets/src/util/errorUtils.d.ts

@@ -0,0 +1 @@
+export { normaliseError, getErrorMessage, hasErrorCode, getErrorCode, getErrorStack, formatErrorString } from "@fjall/util";

package/bin/assets/src/util/errorUtils.js

@@ -0,0 +1 @@
+import{normaliseError as e,getErrorMessage as t,hasErrorCode as E,getErrorCode as a,getErrorStack as g,formatErrorString as s}from"@fjall/util";export{s as formatErrorString,a as getErrorCode,t as getErrorMessage,g as getErrorStack,E as hasErrorCode,e as normaliseError};

package/bin/assets/src/util/executionMode.d.ts

@@ -0,0 +1,18 @@
+export interface NonInteractiveOptions {
+    nonInteractive?: boolean;
+    agent?: boolean;
+}
+/**
+ * Re-export of agent-mode detection from `./agent/detectAgent.js`.
+ * Explicit `options.agent` (true/false) is a hard override; otherwise
+ * auto-detection runs (env signals + TTY gate).
+ */
+export declare function isAgentMode(options?: {
+    agent?: boolean;
+}): boolean;
+/**
+ * Determines if the CLI should run in non-interactive mode.
+ * Triggered when --non-interactive flag is set, stdout is not a TTY,
+ * or agent mode is active (agent mode implies non-interactive).
+ */
+export declare function isNonInteractiveMode(options?: NonInteractiveOptions): boolean;

package/bin/assets/src/util/executionMode.js

@@ -0,0 +1 @@
+import{isAgentMode as t}from"./agent/detectAgent.js";function n(e){return t(e)}function o(e){return n(e)?!0:e?.nonInteractive||!process.stdout.isTTY}export{n as isAgentMode,o as isNonInteractiveMode};

package/bin/assets/src/util/formatDeltaValue.d.ts

@@ -0,0 +1 @@
+export declare function formatDeltaValue(value: unknown): string;

package/bin/assets/src/util/formatDeltaValue.js

@@ -0,0 +1 @@
+import{logger as n}from"./logger/index.js";function i(r){if(r===void 0)return"(not set)";if(r===null)return"null";if(typeof r=="string")return r;if(typeof r=="boolean"||typeof r=="number")return String(r);try{return JSON.stringify(r)}catch(t){return n.debug("formatDeltaValue","JSON.stringify failed",{error:t instanceof Error?t.message:String(t)}),String(r)}}export{i as formatDeltaValue};

package/bin/assets/src/util/formatDuration.d.ts

@@ -0,0 +1 @@
+export declare function formatDuration(ms: number): string;

package/bin/assets/src/util/formatDuration.js

@@ -0,0 +1 @@
+const S=1e3,_=60;function r(n){if(n<1e3)return"<1s";const E=Math.floor(n/1e3);if(E<60)return`${E}s`;const t=Math.floor(E/60),o=E%60;return o>0?`${t}m ${o}s`:`${t}m`}export{r as formatDuration};

package/bin/assets/src/util/formatRelativeTime.d.ts

@@ -0,0 +1 @@
+export declare function formatRelativeTime(input: string | Date | number, now?: number): string;

package/bin/assets/src/util/formatRelativeTime.js

@@ -0,0 +1 @@
+const E=1e3,c=6e4,M=36e5,i=864e5,D=6048e5,N=2592e6,l=31536e6;function u(o,a=Date.now()){const r=(typeof o=="number"?new Date(o):o instanceof Date?o:new Date(o)).getTime();if(Number.isNaN(r))return"\u2014";const e=a-r,f=e<0,t=Math.abs(e),n=t<6e4?`${Math.floor(t/1e3)}s`:t<36e5?`${Math.floor(t/6e4)}m`:t<864e5?`${Math.floor(t/36e5)}h`:t<6048e5?`${Math.floor(t/864e5)}d`:t<2592e6?`${Math.floor(t/6048e5)}w`:t<31536e6?`${Math.floor(t/2592e6)}mo`:`${Math.floor(t/31536e6)}y`;return f?`in ${n}`:`${n} ago`}export{u as formatRelativeTime};

package/bin/assets/src/util/fuzzyMatch.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Fuzzy matching algorithm for type-to-search interfaces.
+ *
+ * Scoring tiers:
+ * - Exact match: 100
+ * - Prefix match: 80
+ * - Contains (in label): 60
+ * - Contains (in description): 50
+ * - Fuzzy (chars in order): 20 + bonuses for consecutive/early matches
+ */
+export interface FuzzyPickerOption {
+    label: string;
+    value: string;
+    description?: string;
+    /** Optional category for grouped display */
+    category?: string;
+}
+export interface FuzzyMatchResult {
+    /** The matched score (0-100+). Higher = better match */
+    score: number;
+    /** Indices of matched characters in the label (for highlight rendering) */
+    indices: number[];
+}
+export interface FuzzyFilterResult<T> {
+    item: T;
+    score: number;
+    indices: number[];
+}
+/**
+ * Score a single query against a text string.
+ * Returns the match result or null if no match.
+ */
+export declare function fuzzyMatch(query: string, text: string): FuzzyMatchResult | null;
+/**
+ * Filter and sort items by fuzzy match score.
+ * Items that don't match are excluded. Results sorted by score descending.
+ */
+export declare function fuzzyFilter<T>(query: string, items: readonly T[], getText: (item: T) => string, getDescription?: (item: T) => string | undefined): Array<FuzzyFilterResult<T>>;

package/bin/assets/src/util/fuzzyMatch.js

@@ -0,0 +1 @@
+const E=100,N=80,R=60,I=50,l=20,h=5,T=10,d=3;function S(o,e){if(!o)return{score:0,indices:[]};const n=o.toLowerCase(),c=e.toLowerCase();if(c===n)return{score:100,indices:Array.from({length:o.length},(i,s)=>s)};if(c.startsWith(n))return{score:80,indices:Array.from({length:o.length},(i,s)=>s)};const r=c.indexOf(n);if(r>=0)return{score:60,indices:Array.from({length:o.length},(i,s)=>r+s)};const t=u(n,c);if(t.length===n.length){const i=_(t)*5,s=t[0]===0?10:0,O=(t[0]??0)<5?3:0;return{score:20+i+s+O,indices:t}}return null}function a(o,e,n,c){if(!o)return e.map(t=>({item:t,score:0,indices:[]}));const r=[];for(const t of e){const i=n(t),s=S(o,i);if(s){r.push({item:t,score:s.score,indices:s.indices});continue}const O=c?.(t);if(O){const C=S(o,O);if(C){const f=C.score>=60?50:40;r.push({item:t,score:f,indices:[]})}}}return r.sort((t,i)=>i.score-t.score)}function u(o,e){const n=[];let c=0;for(const r of o){const t=e.indexOf(r,c);if(t<0)return n;n.push(t),c=t+1}return n}function _(o){let e=0;for(let n=1;n<o.length;n++)o[n]===(o[n-1]??0)+1&&e++;return e}export{a as fuzzyFilter,S as fuzzyMatch};

package/bin/assets/src/util/gitDetection.d.ts

@@ -0,0 +1,8 @@
+import type { GitProvider } from "@fjall/util";
+export interface GitInfo {
+    remoteUrl: string;
+    branch: string;
+    commitSha: string;
+    provider: GitProvider;
+}
+export declare function detectGitInfo(cwd?: string): GitInfo | null;

package/bin/assets/src/util/gitDetection.js

@@ -0,0 +1 @@
+import{execFileSync as e}from"child_process";import{parseGitRemoteUrl as s,filterDangerousEnvVars as m}from"@fjall/util";const u=5e3;function f(o){try{const r={timeout:u,encoding:"utf-8",env:{...m(process.env),GIT_TERMINAL_PROMPT:"0"},...o!==void 0&&{cwd:o}},t=e("git",["remote","get-url","origin"],r).trim();if(!t)return null;const n=e("git",["rev-parse","HEAD"],r).trim(),i=e("git",["branch","--show-current"],r).trim(),c=s(t)?.provider??"other";return{remoteUrl:t,branch:i,commitSha:n,provider:c}}catch{return null}}export{f as detectGitInfo};