@ericminassian/plat 0.0.0-stage → 0.2.0

package/src/dev/worker.ts

@@ -0,0 +1,332 @@
+import { type ChildProcess, spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import {
+  EventBridgeClient,
+  ListRulesCommand,
+  ListTargetsByRuleCommand,
+  PutTargetsCommand,
+  RemoveTargetsCommand,
+} from '@aws-sdk/client-eventbridge';
+import {
+  LambdaClient,
+  ListEventSourceMappingsCommand,
+  UpdateEventSourceMappingCommand,
+} from '@aws-sdk/client-lambda';
+import {
+  CreateQueueCommand,
+  DeleteMessageBatchCommand,
+  GetQueueAttributesCommand,
+  type Message,
+  ReceiveMessageCommand,
+  SetQueueAttributesCommand,
+  SQSClient,
+} from '@aws-sdk/client-sqs';
+import { names, type ResolvedManifest } from '@ericminassian/platform-core';
+import { SDK_WORKER } from '../build.ts';
+import { resolveFromApp } from '../project.ts';
+import { freePort, waitForPort } from '../util/net.ts';
+import { tsxArgs } from './entries.ts';
+import { emulatorClientConfig, type LocalStage, localEnv } from './local-stage.ts';
+import { killTree } from './proc.ts';
+
+/**
+ * Local worker: the app's worker in a real Node process (see worker-host.ts
+ * for why), fed by a dispatcher that does what Lambda's event sources would:
+ * polls each SQS queue (batches, partial failures, retries via visibility
+ * timeout, DLQ via the queue's redrive policy), receives EventBridge events
+ * through a tap queue, and runs crons on demand.
+ */
+export interface InvokeResult {
+  ok: boolean;
+  result?: unknown;
+  error?: { name: string; message: string; stack?: string };
+}
+
+export interface LocalWorker {
+  port: number;
+  child: ChildProcess;
+  invoke(event: unknown): Promise<InvokeResult>;
+  stop(): void;
+}
+
+export async function startLocalWorker(
+  stage: LocalStage,
+  manifest: ResolvedManifest,
+  root: string,
+  opts: { watch?: boolean } = {},
+): Promise<LocalWorker> {
+  if (!manifest.worker) throw new Error('manifest has no worker');
+  const port = await freePort();
+  const env = localEnv(stage, manifest, {
+    PLATFORM_WORKER_ENTRY: resolve(root, manifest.worker.entry),
+    PLATFORM_SDK_WORKER: resolveFromApp(root, SDK_WORKER),
+    PLATFORM_WORKER_PORT: String(port),
+    PLATFORM_WORKER_TIMEOUT_MS: String(manifest.worker.timeoutSeconds * 1000),
+    PLATFORM_WORKER_FUNCTION:
+      stage.result.workerFunction?.name ?? names.workerFunction(manifest.name, stage.stage),
+    PLATFORM_LOG_PRETTY: '1',
+  });
+  const child = spawn(process.execPath, tsxArgs('worker-host', opts.watch !== false), {
+    cwd: root,
+    env,
+    detached: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  await waitForPort(port, '127.0.0.1', 60_000);
+  return {
+    port,
+    child,
+    async invoke(event) {
+      // tsx watch restarts the host on edits; wait for it to come back.
+      await waitForPort(port, '127.0.0.1', 30_000);
+      const res = await fetch(`http://127.0.0.1:${port}/`, { method: 'POST', body: JSON.stringify(event) });
+      return (await res.json()) as InvokeResult;
+    },
+    stop() {
+      killTree(child);
+    },
+  };
+}
+
+export type DispatchLog = (
+  kind: 'queue' | 'event' | 'cron',
+  name: string,
+  outcome: 'ok' | 'error',
+  detail?: string,
+) => void;
+
+export interface Dispatcher {
+  runCron(name: string): Promise<InvokeResult>;
+  stop(): void;
+}
+
+export async function startWorkerDispatch(
+  stage: LocalStage,
+  manifest: ResolvedManifest,
+  worker: Pick<LocalWorker, 'invoke'>,
+  log: DispatchLog = () => {},
+): Promise<Dispatcher> {
+  const cfg = emulatorClientConfig(stage.conn);
+  const sqs = new SQSClient(cfg);
+  const lambda = new LambdaClient(cfg);
+  const events = new EventBridgeClient(cfg);
+  const functionName = stage.result.workerFunction?.name;
+  let stopped = false;
+
+  // The emulator's own event source mappings would hand messages to its sandboxed runtime; turn them off.
+  if (functionName) {
+    const esms = await lambda
+      .send(new ListEventSourceMappingsCommand({ FunctionName: functionName }))
+      .catch(() => undefined);
+    for (const m of esms?.EventSourceMappings ?? []) {
+      if (m.UUID && m.State !== 'Disabled') {
+        await lambda
+          .send(new UpdateEventSourceMappingCommand({ UUID: m.UUID, Enabled: false }))
+          .catch(() => undefined);
+      }
+    }
+  }
+
+  const loops: Array<Promise<void>> = [];
+  for (const [name, q] of Object.entries(stage.bindings.queues)) {
+    const batchSize = manifest.queues[name]?.batchSize ?? 10;
+    loops.push(
+      pollQueue(
+        sqs,
+        q.url,
+        batchSize,
+        () => stopped,
+        async (messages) => {
+          const r = await worker.invoke(sqsEvent(messages, q.arn, stage.conn.region));
+          const failed = new Set(
+            r.ok
+              ? (
+                  (r.result as { batchItemFailures?: Array<{ itemIdentifier: string }> } | null)
+                    ?.batchItemFailures ?? []
+                ).map((f) => f.itemIdentifier)
+              : messages.map((m) => m.MessageId!),
+          );
+          log(
+            'queue',
+            name,
+            failed.size ? 'error' : 'ok',
+            r.ok ? (failed.size ? `${failed.size} failed` : undefined) : r.error?.message,
+          );
+          return messages.filter((m) => !failed.has(m.MessageId!));
+        },
+      ),
+    );
+  }
+
+  if (functionName && stage.bindings.bus) {
+    const tapUrl = await tapEventRules(sqs, events, stage, functionName);
+    if (tapUrl) {
+      loops.push(
+        pollQueue(
+          sqs,
+          tapUrl,
+          1,
+          () => stopped,
+          async (messages) => {
+            const done: Message[] = [];
+            for (const m of messages) {
+              const event = JSON.parse(m.Body ?? '{}') as { 'detail-type'?: string };
+              const attempts = Number(m.Attributes?.ApproximateReceiveCount ?? '1');
+              const r = await worker.invoke(event);
+              log('event', event['detail-type'] ?? '?', r.ok ? 'ok' : 'error', r.error?.message);
+              // Lambda async invokes retry twice, then drop: same here.
+              if (r.ok || attempts >= 3) done.push(m);
+            }
+            return done;
+          },
+          5,
+        ),
+      );
+    }
+  }
+
+  return {
+    async runCron(name) {
+      const r = await worker.invoke({ __platform: 'cron', name });
+      log('cron', name, r.ok ? 'ok' : 'error', r.error?.message);
+      return r;
+    },
+    stop() {
+      stopped = true;
+      sqs.destroy();
+      lambda.destroy();
+      events.destroy();
+    },
+  };
+}
+
+/** Lambda's SQS event shape. */
+export function sqsEvent(messages: Message[], queueArn: string, region: string) {
+  return {
+    Records: messages.map((m) => ({
+      messageId: m.MessageId,
+      receiptHandle: m.ReceiptHandle,
+      body: m.Body ?? '',
+      attributes: m.Attributes ?? {},
+      messageAttributes: Object.fromEntries(
+        Object.entries(m.MessageAttributes ?? {}).map(([k, v]) => [
+          k,
+          {
+            stringValue: v.StringValue,
+            binaryValue: v.BinaryValue,
+            dataType: v.DataType,
+            stringListValues: [],
+            binaryListValues: [],
+          },
+        ]),
+      ),
+      md5OfBody: m.MD5OfBody,
+      eventSource: 'aws:sqs',
+      eventSourceARN: queueArn,
+      awsRegion: region,
+    })),
+  };
+}
+
+/**
+ * Re-point the stage's EventBridge rules from the (sandboxed) emulator Lambda
+ * to a tap queue the dispatcher polls. Returns the tap queue URL.
+ */
+async function tapEventRules(
+  sqs: SQSClient,
+  events: EventBridgeClient,
+  stage: LocalStage,
+  functionName: string,
+): Promise<string | null> {
+  const bus = stage.bindings.bus!.name;
+  const rules =
+    (await events.send(new ListRulesCommand({ EventBusName: bus })).catch(() => undefined))?.Rules ?? [];
+  if (rules.length === 0) return null;
+  const tapName = `${names.base(stage.bindings.app, stage.stage)}--plat-dev-events`;
+  const tapUrl = (await sqs.send(new CreateQueueCommand({ QueueName: tapName }))).QueueUrl!;
+  const tapArn = (
+    await sqs.send(new GetQueueAttributesCommand({ QueueUrl: tapUrl, AttributeNames: ['QueueArn'] }))
+  ).Attributes!.QueueArn!;
+  await sqs.send(
+    new SetQueueAttributesCommand({
+      QueueUrl: tapUrl,
+      Attributes: {
+        Policy: JSON.stringify({
+          Version: '2012-10-17',
+          Statement: [
+            {
+              Effect: 'Allow',
+              Principal: { Service: 'events.amazonaws.com' },
+              Action: 'sqs:SendMessage',
+              Resource: tapArn,
+            },
+          ],
+        }),
+      },
+    }),
+  );
+  for (const rule of rules) {
+    if (!rule.Name) continue;
+    const targets =
+      (await events.send(new ListTargetsByRuleCommand({ Rule: rule.Name, EventBusName: bus }))).Targets ?? [];
+    const lambdaTargets = targets.filter((t) => t.Arn?.includes(`:function:${functionName}`));
+    if (lambdaTargets.length === 0) continue;
+    await events.send(
+      new RemoveTargetsCommand({ Rule: rule.Name, EventBusName: bus, Ids: lambdaTargets.map((t) => t.Id!) }),
+    );
+    await events.send(
+      new PutTargetsCommand({
+        Rule: rule.Name,
+        EventBusName: bus,
+        Targets: [{ Id: 'plat-dev-tap', Arn: tapArn }],
+      }),
+    );
+  }
+  return tapUrl;
+}
+
+/** Long-poll a queue; `handle` returns the messages to delete. */
+async function pollQueue(
+  sqs: SQSClient,
+  url: string,
+  batchSize: number,
+  stopped: () => boolean,
+  handle: (messages: Message[]) => Promise<Message[]>,
+  waitSeconds = 5,
+): Promise<void> {
+  while (!stopped()) {
+    let messages: Message[] = [];
+    try {
+      messages =
+        (
+          await sqs.send(
+            new ReceiveMessageCommand({
+              QueueUrl: url,
+              MaxNumberOfMessages: batchSize,
+              WaitTimeSeconds: waitSeconds,
+              MessageSystemAttributeNames: ['All'],
+              MessageAttributeNames: ['All'],
+            }),
+          )
+        ).Messages ?? [];
+    } catch {
+      if (stopped()) return;
+      await new Promise((r) => setTimeout(r, 1_000));
+      continue;
+    }
+    if (messages.length === 0) continue;
+    try {
+      const done = await handle(messages);
+      if (done.length) {
+        await sqs.send(
+          new DeleteMessageBatchCommand({
+            QueueUrl: url,
+            Entries: done.map((m, i) => ({ Id: String(i), ReceiptHandle: m.ReceiptHandle! })),
+          }),
+        );
+      }
+    } catch {
+      // Leave the messages; they become visible again after the visibility timeout.
+    }
+  }
+}

package/src/github.ts

@@ -0,0 +1,121 @@
+import { execFileSync } from 'node:child_process';
+import { appendFileSync, readFileSync } from 'node:fs';
+import { PROD_STAGE, previewStage, validateStageName } from '@ericminassian/platform-core';
+import { CliError, EXIT } from './util/output.ts';
+
+/** GitHub Actions environment, read from `process.env` (injectable for tests). */
+export type Env = Record<string, string | undefined>;
+
+export function isGitHubActions(env: Env = process.env): boolean {
+  return env.GITHUB_ACTIONS === 'true';
+}
+
+interface GitHubEvent {
+  number?: number;
+  pull_request?: { number?: number; head?: { sha?: string; ref?: string }; title?: string };
+  head_commit?: { message?: string };
+  repository?: { default_branch?: string };
+}
+
+export function readEvent(env: Env = process.env): GitHubEvent {
+  if (!env.GITHUB_EVENT_PATH) return {};
+  try {
+    return JSON.parse(readFileSync(env.GITHUB_EVENT_PATH, 'utf8')) as GitHubEvent;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * The stage a CI run deploys to: `pr-<n>` for pull requests, `prod` for pushes
+ * (or manual runs) on the default branch. `explicit` (from `--stage`) wins.
+ */
+export function deriveStage(explicit: string | undefined, env: Env = process.env): string {
+  if (explicit) {
+    const err = validateStageName(explicit);
+    if (err) throw new CliError(err, { exitCode: EXIT.usage });
+    return explicit;
+  }
+  if (!isGitHubActions(env)) {
+    throw new CliError('no stage given', {
+      hint: 'pass --stage <name> (CI derives it: pull requests → pr-<n>, main → prod)',
+      exitCode: EXIT.usage,
+    });
+  }
+  const event = readEvent(env);
+  const name = env.GITHUB_EVENT_NAME;
+  if (name === 'pull_request' || name === 'pull_request_target') {
+    const n = event.pull_request?.number ?? event.number;
+    if (!n) throw new CliError('pull_request event without a PR number', { exitCode: EXIT.usage });
+    return previewStage(n);
+  }
+  const defaultBranch = event.repository?.default_branch ?? 'main';
+  if (env.GITHUB_REF === `refs/heads/${defaultBranch}`) return PROD_STAGE;
+  throw new CliError(
+    `can't derive a stage for ${name ?? 'this event'} on ${env.GITHUB_REF ?? 'unknown ref'}`,
+    {
+      hint: 'pass --stage explicitly',
+      exitCode: EXIT.usage,
+    },
+  );
+}
+
+/** Commit metadata for the deployment record. */
+export function gitInfo(
+  cwd: string,
+  env: Env = process.env,
+): { commit?: string; ref?: string; message?: string } {
+  if (isGitHubActions(env)) {
+    const event = readEvent(env);
+    return {
+      commit: event.pull_request?.head?.sha ?? env.GITHUB_SHA,
+      ref: event.pull_request?.head?.ref ? `refs/heads/${event.pull_request.head.ref}` : env.GITHUB_REF,
+      message: (event.pull_request?.title ?? event.head_commit?.message)?.split('\n')[0],
+    };
+  }
+  const git = (...args: string[]) => {
+    try {
+      return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    } catch {
+      return undefined;
+    }
+  };
+  const branch = git('rev-parse', '--abbrev-ref', 'HEAD');
+  return {
+    commit: git('rev-parse', 'HEAD'),
+    ref: branch ? `refs/heads/${branch}` : undefined,
+    message: git('log', '-1', '--format=%s'),
+  };
+}
+
+/** GitHub Actions OIDC token for `audience` (requires `permissions: id-token: write`). */
+export async function fetchOidcToken(audience: string, env: Env = process.env): Promise<string> {
+  const url = env.ACTIONS_ID_TOKEN_REQUEST_URL;
+  const token = env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
+  if (!url || !token) {
+    throw new CliError('GitHub Actions OIDC is not available', {
+      hint: 'add `permissions: { id-token: write }` to the workflow',
+      exitCode: EXIT.auth,
+    });
+  }
+  const res = await fetch(`${url}${url.includes('?') ? '&' : '?'}audience=${encodeURIComponent(audience)}`, {
+    headers: { authorization: `bearer ${token}`, accept: 'application/json' },
+  });
+  if (!res.ok) throw new CliError(`OIDC token request failed: HTTP ${res.status}`, { exitCode: EXIT.auth });
+  const body = (await res.json()) as { value?: string };
+  if (!body.value) throw new CliError('OIDC token response had no value', { exitCode: EXIT.auth });
+  return body.value;
+}
+
+export function canUseOidc(env: Env = process.env): boolean {
+  return isGitHubActions(env) && !!env.ACTIONS_ID_TOKEN_REQUEST_URL && !!env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
+}
+
+/** `key=value` into `$GITHUB_OUTPUT` (no-op outside Actions). */
+export function setOutput(key: string, value: string, env: Env = process.env): void {
+  if (env.GITHUB_OUTPUT) appendFileSync(env.GITHUB_OUTPUT, `${key}=${value}\n`);
+}
+
+export function appendStepSummary(markdown: string, env: Env = process.env): void {
+  if (env.GITHUB_STEP_SUMMARY) appendFileSync(env.GITHUB_STEP_SUMMARY, `${markdown}\n`);
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+/**
+ * @ericminassian/plat — programmatic API of the CLI. The foundation deploy
+ * and tests import `buildApp`; everything else is for the `plat` binary.
+ */
+export { ApiClient, ApiError, apiBaseUrl } from './api.ts';
+export { type BuildOptions, type BuildResult, buildApp, bundleWorker, validateForBuild } from './build.ts';
+export { configDir, credentialsPath, loadCredentials, type StoredCredentials } from './credentials.ts';
+export {
+  type DeployOptions,
+  type DeployResult,
+  deploy,
+  presignedPostForm,
+  waitForDeployment,
+} from './deploy.ts';
+export { type LocalStage, localEnv, startLocalStage } from './dev/local-stage.ts';
+export { deriveStage, fetchOidcToken, gitInfo, isGitHubActions } from './github.ts';
+export { type InitOptions, type InitResult, initApp, TEMPLATE_APP_NAME } from './init.ts';
+export { createProgram, main } from './main.ts';
+export { findProjectRoot, loadProject, type Project } from './project.ts';
+export { CliError, EXIT } from './util/output.ts';

package/src/init.ts

@@ -0,0 +1,136 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { basename, dirname, extname, join, relative, resolve } from 'node:path';
+import { APP_CONFIG_FILE, validateAppName } from '@ericminassian/platform-core';
+import { cliPackageRoot, cliVersion } from './project.ts';
+import { CliError, EXIT } from './util/output.ts';
+
+/** The app name used throughout `templates/app`; replaced on `plat init`. */
+export const TEMPLATE_APP_NAME = 'template-app';
+export const TEMPLATE_PACKAGE_NAME = 'platform-app-template';
+/** Written into new apps so CI's corepack uses the same pnpm as the platform. */
+export const PACKAGE_MANAGER = 'pnpm@12.11.2';
+
+const SKIP = new Set(['node_modules', '.plat', 'dist', 'coverage', '.turbo']);
+const TEXT_EXT = new Set([
+  '.ts',
+  '.tsx',
+  '.js',
+  '.mjs',
+  '.cjs',
+  '.json',
+  '.md',
+  '.html',
+  '.css',
+  '.yml',
+  '.yaml',
+  '.txt',
+  '.gitignore',
+  '',
+]);
+
+/** Published CLI: `template/` inside the package. In this repo: `templates/app`. */
+export function templateDir(): string {
+  const packaged = join(cliPackageRoot(), 'template');
+  if (existsSync(join(packaged, APP_CONFIG_FILE))) return packaged;
+  const repo = resolve(cliPackageRoot(), '..', '..', 'templates', 'app');
+  if (existsSync(join(repo, APP_CONFIG_FILE))) return repo;
+  throw new CliError('app template not found (broken CLI install?)');
+}
+
+export interface InitOptions {
+  dir: string;
+  name?: string;
+  force?: boolean;
+  /** Version range written for platform packages. Default `^<cli version>`. */
+  versionRange?: string;
+  template?: string;
+}
+
+export interface InitResult {
+  dir: string;
+  name: string;
+  files: string[];
+}
+
+export function initApp(opts: InitOptions): InitResult {
+  const dir = resolve(opts.dir);
+  const name = opts.name ?? basename(dir);
+  const err = validateAppName(name);
+  if (err) throw new CliError(`invalid app name: ${err}`, { exitCode: EXIT.usage });
+  if (existsSync(dir) && readdirSync(dir).filter((f) => f !== '.git').length > 0 && !opts.force) {
+    throw new CliError(`${dir} is not empty`, {
+      hint: 'choose an empty directory or pass --force',
+      exitCode: EXIT.usage,
+    });
+  }
+  const src = opts.template ?? templateDir();
+  const range = opts.versionRange ?? `^${cliVersion()}`;
+  const files = copyTree(src, dir, (rel, content) =>
+    rel === 'package.json' ? rewritePackageJson(content, name, range) : replaceAppName(content, name),
+  );
+  writeFileSync(join(dir, 'pnpm-workspace.yaml'), PNPM_WORKSPACE);
+  files.push('pnpm-workspace.yaml');
+  return { dir, name, files: files.sort() };
+}
+
+/**
+ * pnpm 10+ refuses to install (ERR_PNPM_IGNORED_BUILDS) until a dependency's
+ * install script is allowed, and esbuild (used by `plat build`) has one. It's
+ * written here rather than shipped in templates/app: a pnpm-workspace.yaml
+ * there would make that folder its own workspace inside this monorepo.
+ */
+export const PNPM_WORKSPACE = `# esbuild (used by \`plat build\`) installs its native binary with a build script.
+allowBuilds:
+  esbuild: true
+`;
+
+export function replaceAppName(content: string, name: string): string {
+  return content.split(TEMPLATE_APP_NAME).join(name);
+}
+
+export function rewritePackageJson(content: string, name: string, range: string): string {
+  const pkg = JSON.parse(content) as Record<string, unknown>;
+  pkg.name = name;
+  pkg.packageManager ??= PACKAGE_MANAGER;
+  for (const field of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+    const deps = pkg[field] as Record<string, string> | undefined;
+    if (!deps) continue;
+    for (const [dep, v] of Object.entries(deps)) if (v.startsWith('workspace:')) deps[dep] = range;
+  }
+  return `${JSON.stringify(pkg, null, 2)}\n`;
+}
+
+/** Copies `src` to `dest`, transforming text files; returns the written paths (relative). */
+function copyTree(src: string, dest: string, transform: (rel: string, content: string) => string): string[] {
+  const written: string[] = [];
+  const walk = (from: string) => {
+    for (const entry of readdirSync(from, { withFileTypes: true })) {
+      if (SKIP.has(entry.name)) continue;
+      const abs = join(from, entry.name);
+      const rel = relative(src, abs).split('\\').join('/');
+      if (rel === 'web/dist') continue;
+      if (entry.isDirectory()) {
+        walk(abs);
+        continue;
+      }
+      // npm drops `.gitignore` from packages, so the published template stores `_gitignore`.
+      const outRel = rel.replace(/(^|\/)_gitignore$/, '$1.gitignore');
+      const target = join(dest, outRel);
+      mkdirSync(dirname(target), { recursive: true });
+      const isText = TEXT_EXT.has(extname(entry.name)) && statSync(abs).size < 1_000_000;
+      if (isText) writeFileSync(target, transform(outRel, readFileSync(abs, 'utf8')));
+      else copyFileSync(abs, target);
+      written.push(outRel);
+    }
+  };
+  walk(src);
+  return written;
+}

package/src/main.ts

@@ -0,0 +1,28 @@
+import { Command } from 'commander';
+import { registerAccount } from './commands/account.ts';
+import { registerApps } from './commands/apps.ts';
+import { registerLifecycle } from './commands/lifecycle.ts';
+import { registerManage } from './commands/manage.ts';
+import { registerObserve } from './commands/observe.ts';
+import { cliVersion } from './project.ts';
+
+export function createProgram(): Command {
+  const program = new Command('plat')
+    .description(
+      'The platform CLI: create, run locally (AWS Emulator), deploy and observe apps.\nEvery command accepts --json for machine-readable output.',
+    )
+    .version(cliVersion(), '-v, --version')
+    .showHelpAfterError('(run with --help for usage)')
+    .configureHelp({ sortSubcommands: false });
+
+  registerLifecycle(program);
+  registerApps(program);
+  registerAccount(program);
+  registerObserve(program);
+  registerManage(program);
+  return program;
+}
+
+export async function main(argv: string[]): Promise<void> {
+  await createProgram().parseAsync(argv);
+}