const ROOT_HELP_RENDER_TIMEOUT_MS = 120_000;

const BROWSER_HELP_RENDER_TIMEOUT_MS = 120_000;

const COMMAND_HELP_RENDER_TIMEOUT_MS = 120_000;

const PRECOMPUTED_SUBCOMMAND_HELP_COMMANDS = ["doctor", "gateway", "models", "plugins"] as const;

const CORE_CHANNEL_ORDER = [

"telegram",

"whatsapp",

signature: string;

};

type PrecomputedSubcommandHelpCommand = (typeof PRECOMPUTED_SUBCOMMAND_HELP_COMMANDS)[number];

type PrecomputedSubcommandHelpText = Record<PrecomputedSubcommandHelpCommand, string>;

type RootHelpRenderContext = Pick<RootHelpRenderOptions, "config" | "env">;

function resolveRootHelpBundleIdentity(

return hash.digest("hex");

}

function resolveSubcommandHelpSourceSignature(sourceRootDir: string = rootDir): string {

const hash = createHash("sha1");

updateHashFromFiles(

hash,

[

path.join(sourceRootDir, "src/cli/program/help.ts"),

path.join(sourceRootDir, "src/cli/program/context.ts"),

path.join(sourceRootDir, "src/cli/banner.ts"),

path.join(sourceRootDir, "src/cli/help-format.ts"),

path.join(sourceRootDir, "src/cli/daemon-cli/register-service-commands.ts"),

path.join(sourceRootDir, "src/cli/program/register.maintenance.ts"),

path.join(sourceRootDir, "src/cli/gateway-cli.ts"),

path.join(sourceRootDir, "src/cli/gateway-cli/register.ts"),

path.join(sourceRootDir, "src/cli/gateway-cli/run-command.ts"),

path.join(sourceRootDir, "src/cli/models-cli.ts"),

path.join(sourceRootDir, "src/cli/plugins-cli.ts"),

path.join(sourceRootDir, "src/terminal/links.ts"),

path.join(sourceRootDir, "src/terminal/theme.ts"),

],

sourceRootDir,

);

return hash.digest("hex");

}

export function readBundledChannelCatalog(

extensionsDirOverride: string = extensionsDir,

): BundledChannelCatalog {

}

function renderSourceCommandHelpText(

command: "nodes" | "secrets",

command: "nodes" | "secrets" | PrecomputedSubcommandHelpCommand,

renderContext: RootHelpRenderContext = createIsolatedRootHelpRenderContext(),

): string {

const result = spawnSync(

return renderSourceCommandHelpText("nodes", renderContext);

}

function renderSourceSubcommandHelpTextRecord(

renderContext: RootHelpRenderContext = createIsolatedRootHelpRenderContext(),

): PrecomputedSubcommandHelpText {

const entries = PRECOMPUTED_SUBCOMMAND_HELP_COMMANDS.map((commandName) => [

commandName,

renderSourceCommandHelpText(commandName, renderContext),

]);

return Object.fromEntries(entries) as PrecomputedSubcommandHelpText;

}

export async function writeCliStartupMetadata(options?: {

distDir?: string;

outputPath?: string;

renderSourceBrowserHelpText?: typeof renderSourceBrowserHelpText;

renderSourceSecretsHelpText?: typeof renderSourceSecretsHelpText;

renderSourceNodesHelpText?: typeof renderSourceNodesHelpText;

renderSourceSubcommandHelpTextRecord?: typeof renderSourceSubcommandHelpTextRecord;

}): Promise<void> {

const resolvedDistDir = options?.distDir ?? distDir;

const resolvedOutputPath = options?.outputPath ?? outputPath;

const browserHelpSourceSignature = resolveBrowserHelpSourceSignature(resolvedSourceRootDir);

const secretsHelpSourceSignature = resolveSecretsHelpSourceSignature(resolvedSourceRootDir);

const nodesHelpSourceSignature = resolveNodesHelpSourceSignature(resolvedSourceRootDir);

const subcommandHelpSourceSignature = resolveSubcommandHelpSourceSignature(resolvedSourceRootDir);

const bundledPluginsDir = path.join(resolvedDistDir, "extensions");

const renderContext = createIsolatedRootHelpRenderContext(

existsSync(bundledPluginsDir) ? bundledPluginsDir : resolvedExtensionsDir,

browserHelpSourceSignature?: unknown;

secretsHelpSourceSignature?: unknown;

nodesHelpSourceSignature?: unknown;

subcommandHelpSourceSignature?: unknown;

channelCatalogSignature?: unknown;

browserHelpText?: unknown;

secretsHelpText?: unknown;

nodesHelpText?: unknown;

subcommandHelpText?: unknown;

};

if (

bundleIdentity &&

existing.rootHelpBundleSignature === bundleIdentity.signature &&

existing.browserHelpSourceSignature === browserHelpSourceSignature &&

existing.secretsHelpSourceSignature === secretsHelpSourceSignature &&

existing.nodesHelpSourceSignature === nodesHelpSourceSignature &&

existing.subcommandHelpSourceSignature === subcommandHelpSourceSignature &&

existing.channelCatalogSignature === channelCatalog.signature &&

typeof existing.browserHelpText === "string" &&

existing.browserHelpText.length > 0 &&

typeof existing.secretsHelpText === "string" &&

existing.secretsHelpText.length > 0 &&

typeof existing.nodesHelpText === "string" &&

existing.nodesHelpText.length > 0

existing.nodesHelpText.length > 0 &&

hasAllPrecomputedSubcommandHelpText(existing.subcommandHelpText)

) {

return;

}

const nodesHelpText = (options?.renderSourceNodesHelpText ?? renderSourceNodesHelpText)(

renderContext,

);

const subcommandHelpText = (

options?.renderSourceSubcommandHelpTextRecord ?? renderSourceSubcommandHelpTextRecord

)(renderContext);

mkdirSync(resolvedDistDir, { recursive: true });

writeFileSync(

browserHelpSourceSignature,

secretsHelpSourceSignature,

nodesHelpSourceSignature,

subcommandHelpSourceSignature,

browserHelpText,

secretsHelpText,

nodesHelpText,

subcommandHelpText,

rootHelpText,

},

null,

);

}

function hasAllPrecomputedSubcommandHelpText(value: unknown): boolean {

if (typeof value !== "object" || value === null) {

return false;

}

const record = value as Partial<Record<PrecomputedSubcommandHelpCommand, unknown>>;

return PRECOMPUTED_SUBCOMMAND_HELP_COMMANDS.every(

(commandName) => typeof record[commandName] === "string" && record[commandName].length > 0,

);

}

if (process.argv[1] && path.resolve(process.argv[1]) === scriptPath) {

await writeCliStartupMetadata();

process.exit(0);