@gaonjs/cli 0.1.5 → 0.1.7

package/dist/domain.d.ts

@@ -0,0 +1,11 @@
+import { type ScheduleDef } from '@gaonjs/async';
+export interface LoadedDomain {
+    readonly jobs: number;
+    readonly listeners: number;
+    readonly schedule?: ScheduleDef;
+}
+/**
+ * domain/ 을 스캔·import 해 잡·리스너·스케줄을 등록한다. 반환값은 등록 요약.
+ * .ts 상대 import 해석을 위해 tsResolve 훅을 먼저 켠다.
+ */
+export declare function loadDomain(root: string): Promise<LoadedDomain>;

package/dist/domain.js

@@ -0,0 +1,72 @@
+/**
+ * @gaonjs/cli · 도메인 로더 (§7 M7 — 파일=등록)
+ *
+ * `gaon work`(그리고 향후 serve)가 부팅 시 도메인의 비동기 자산을 불러
+ * 레지스트리를 채운다. 관례대로 **디렉터리에 파일을 놓는 것이 곧 등록**이고,
+ * 잡·리스너의 이름/식별자는 파일명에서 채운다(잡은 그래야 `.later()` 가
+ * 어느 프로세스에서든 동작한다 — assignName 이 원본 객체를 mutate).
+ *
+ *  domain/jobs/*.ts        → 잡(이름 = 파일명)
+ *  domain/events/*.ts      → 이벤트 정의(리스너가 참조 · import 만)
+ *  domain/listeners/*.ts   → 리스너(durable id = 파일명)
+ *  domain/schedule.ts      → 스케줄 정의(default export)
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { isJobDef, isListener, reidentifyListener } from '@gaonjs/async';
+import { registerTsResolve } from './tsResolve.js';
+function tsFilesIn(dir) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir, { withFileTypes: true })
+        .filter((e) => e.isFile() && e.name.endsWith('.ts') && !e.name.endsWith('.test.ts'))
+        .map((e) => join(dir, e.name))
+        .sort();
+}
+async function importFile(file) {
+    return (await import(pathToFileURL(file).href));
+}
+/**
+ * domain/ 을 스캔·import 해 잡·리스너·스케줄을 등록한다. 반환값은 등록 요약.
+ * .ts 상대 import 해석을 위해 tsResolve 훅을 먼저 켠다.
+ */
+export async function loadDomain(root) {
+    registerTsResolve();
+    const domainDir = join(root, 'domain');
+    let jobs = 0;
+    let listeners = 0;
+    // 이벤트 정의를 먼저 import 해 리스너가 참조할 수 있게 한다(부수효과 없음).
+    for (const file of tsFilesIn(join(domainDir, 'events')))
+        await importFile(file);
+    for (const file of tsFilesIn(join(domainDir, 'jobs'))) {
+        const mod = await importFile(file);
+        const base = basename(file, '.ts');
+        for (const value of Object.values(mod)) {
+            if (isJobDef(value)) {
+                value.assignName(base);
+                jobs++;
+            }
+        }
+    }
+    for (const file of tsFilesIn(join(domainDir, 'listeners'))) {
+        const mod = await importFile(file);
+        const base = basename(file, '.ts');
+        for (const value of Object.values(mod)) {
+            if (isListener(value)) {
+                reidentifyListener(value, base);
+                listeners++;
+            }
+        }
+    }
+    let schedule;
+    const scheduleFile = join(domainDir, 'schedule.ts');
+    if (existsSync(scheduleFile)) {
+        const mod = await importFile(scheduleFile);
+        const def = mod.default;
+        if (def && typeof def === 'object' && Array.isArray(def.entries)) {
+            schedule = def;
+        }
+    }
+    return { jobs, listeners, schedule };
+}

package/dist/hub.d.ts

@@ -0,0 +1,24 @@
+export interface HubCommandOptions {
+    readonly json?: boolean;
+    /** NATS 접속지. 생략 시 GAON_NATS_URL, 그다음 기본(4222). */
+    readonly natsUrl?: string;
+    /** 리스 TTL(ms). 생략 시 env GAON_HUB_TTL_MS, 그다음 허브 기본(5000). */
+    readonly ttlMs?: number;
+    /** TCP 리슨 포트(errata E-2). 생략 시 env GAON_HUB_PORT, 그다음 4001. */
+    readonly port?: number;
+    /** 소켓 무활동 임계(ms). 생략 시 env GAON_HUB_PING_TIMEOUT_MS. */
+    readonly pingTimeoutMs?: number;
+    /** 무활동·회수 스윕 주기(ms). 생략 시 env GAON_HUB_SWEEP_MS. */
+    readonly sweepMs?: number;
+    /** 시그널 등록·해제(테스트 주입). 기본 process. */
+    readonly signals?: {
+        on(sig: 'SIGINT' | 'SIGTERM', fn: () => void): void;
+        off(sig: 'SIGINT' | 'SIGTERM', fn: () => void): void;
+    };
+}
+/**
+ * 허브를 띄우고 시그널까지 살아 있게 한다. 반환 프라미스는 종료 시 resolve.
+ * 그레이스풀 종료 시 리더 키를 비워(즉시 승계) 대기 인스턴스가 곧바로
+ * 승격하게 한다.
+ */
+export declare function runHubCommand(opts?: HubCommandOptions): Promise<void>;

package/dist/hub.js

@@ -0,0 +1,86 @@
+/**
+ * @gaonjs/cli · `gaon hub` — 실시간 허브 프로세스 (§7 · M6)
+ *
+ * 운영 프로세스 3종(serve · work · hub) 중 하나. 접속자 목록의 단일
+ * 권위이자 중계다(§7 실시간). NATS 에 붙어 프레즌스 명령을 처리하고
+ * KV 에 영속하며, HA 는 리스 기반 리더 선출로 잡는다(active-standby) —
+ * 여러 인스턴스를 띄워도 리더 하나만 명령을 처리한다.
+ *
+ * 개발 모드는 `gaon dev` 가 허브를 같은 프로세스에 내장 실행하므로,
+ * 이 명령은 운영 배치용이다. 모든 명령과 같이 `--json` 을 제공한다.
+ */
+import { hostname } from 'node:os';
+import { connectNats, runHub } from '@gaonjs/async';
+/** 환경변수를 정수로 파싱(미설정·비정상 시 undefined). */
+function envInt(name) {
+    const raw = process.env[name];
+    if (raw == null || raw === '')
+        return undefined;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : undefined;
+}
+function humanEvent(e) {
+    switch (e.kind) {
+        case 'starting':
+            return `  gaon hub · 시작 — ${e.id} (NATS 연결·리더 선출 대기)`;
+        case 'leader':
+            return e.leader
+                ? `  ▶ 리더로 승격 — 프레즌스 명령 처리·KV 권위·델타 중계 시작 (${e.id})`
+                : `  · 대기(standby) — 다른 인스턴스가 리더 (${e.id})`;
+        case 'stopped':
+            return '  gaon hub · 종료';
+    }
+}
+/**
+ * 허브를 띄우고 시그널까지 살아 있게 한다. 반환 프라미스는 종료 시 resolve.
+ * 그레이스풀 종료 시 리더 키를 비워(즉시 승계) 대기 인스턴스가 곧바로
+ * 승격하게 한다.
+ */
+export async function runHubCommand(opts = {}) {
+    const json = opts.json ?? false;
+    const signals = opts.signals ?? process;
+    const id = `${hostname()}#${process.pid}`;
+    const emit = (e) => {
+        if (json)
+            process.stdout.write(JSON.stringify(e) + '\n');
+        else
+            process.stdout.write(humanEvent(e) + '\n');
+    };
+    emit({ kind: 'starting', id });
+    const nats = await connectNats({ servers: opts.natsUrl, name: `hub@${id}` });
+    let hub;
+    try {
+        hub = await runHub({
+            nats,
+            id,
+            // 운영 튜닝: 옵션 > 환경변수 > 허브 기본. 컨테이너 배치에서 헬스체크
+            // 주기에 맞춰 리스 TTL·TCP 포트·소켓 임계를 조정한다.
+            ttlMs: opts.ttlMs ?? envInt('GAON_HUB_TTL_MS'),
+            port: opts.port ?? envInt('GAON_HUB_PORT'),
+            host: process.env.GAON_HUB_HOST,
+            advertiseAddr: process.env.GAON_HUB_ADVERTISE,
+            pingTimeoutMs: opts.pingTimeoutMs ?? envInt('GAON_HUB_PING_TIMEOUT_MS'),
+            sweepMs: opts.sweepMs ?? envInt('GAON_HUB_SWEEP_MS'),
+            reclaimGraceMs: envInt('GAON_HUB_RECLAIM_GRACE_MS'),
+            onState: (s) => emit({ kind: 'leader', leader: s.leader, id }),
+        });
+    }
+    catch (err) {
+        await nats.close();
+        throw err;
+    }
+    await new Promise((resolve) => {
+        const stop = () => {
+            signals.off('SIGINT', stop);
+            signals.off('SIGTERM', stop);
+            void (async () => {
+                await hub.stop();
+                await nats.close();
+                emit({ kind: 'stopped' });
+                resolve();
+            })();
+        };
+        signals.on('SIGINT', stop);
+        signals.on('SIGTERM', stop);
+    });
+}

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 export { runDevCommand, startDev, resolveDevLayout, type DevDeps, type DevLayout, type DevApp, type DevEvent, type DevHandle, type DevCommandOptions, } from "./dev.js";
 export { runCheck, runCheckCommand, type CheckDeps, type CheckResult, type TypecheckResult, type CheckCommandOptions, } from "./check.js";
 export { writeAuthScaffold, authScaffoldFiles, patchRoutes, runGenerateAuthCommand, type AuthScaffoldOptions, type ScaffoldFile, type ScaffoldResult, type GenerateAuthOptions, } from "./generate.js";
+export { runHubCommand, type HubCommandOptions } from "./hub.js";
+export { runWorkCommand, type WorkCommandOptions } from "./work.js";
+export { runJobsCommand, type JobsCommandOptions } from "./jobs.js";
+export { loadDomain, type LoadedDomain } from "./domain.js";
 export interface RoadmapReport {
     readonly name: "gaon";
     readonly version: string;

package/dist/index.js

@@ -13,9 +13,16 @@ import { MILESTONES, VERSION, HOMEPAGE } from "@gaonjs/core";
 import { runDevCommand } from "./dev.js";
 import { runCheckCommand } from "./check.js";
 import { runGenerateAuthCommand } from "./generate.js";
+import { runHubCommand } from "./hub.js";
+import { runWorkCommand } from "./work.js";
+import { runJobsCommand } from "./jobs.js";
 export { runDevCommand, startDev, resolveDevLayout, } from "./dev.js";
 export { runCheck, runCheckCommand, } from "./check.js";
 export { writeAuthScaffold, authScaffoldFiles, patchRoutes, runGenerateAuthCommand, } from "./generate.js";
+export { runHubCommand } from "./hub.js";
+export { runWorkCommand } from "./work.js";
+export { runJobsCommand } from "./jobs.js";
+export { loadDomain } from "./domain.js";
 /** `--json` 출력용 구조화 리포트. */
 export function roadmapReport(version = VERSION) {
     return {
@@ -63,6 +70,10 @@ function renderHelp(version = VERSION) {
         "    gaon dev --json    재생성 이벤트를 JSON 으로 출력",
         "    gaon check         .gaon 재생성 후 타입 검사 (CI·AI 정합)",
         "    gaon g auth        인증 스캐폴드 생성 (회원가입·로그인·세션·보호 라우트)",
+        "    gaon hub           실시간 허브 프로세스 (프레즌스 권위·중계 · 리더 선출 HA)",
+        "    gaon work          워커 프로세스 (잡·리스너·스케줄·아웃박스 · graceful drain)",
+        "    gaon jobs list --failed   DLQ(실패 잡) 목록",
+        "    gaon jobs retry <id>      DLQ 잡 재적재",
         "    gaon --json        같은 정보를 JSON 으로 출력",
         "    gaon --version     버전 출력",
         "    gaon --help        이 도움말",
@@ -97,6 +108,39 @@ export function runCli(argv, opts = {}) {
         });
         return;
     }
+    // `gaon hub` — 실시간 허브 프로세스(§7 M6). 운영 프로세스 3종 중 하나.
+    // NATS·리더 선출 대기로 프로세스를 살려 두고, SIGINT/SIGTERM 에 그레이스풀 종료.
+    if (argv[0] === "hub") {
+        void runHubCommand({ json: argv.includes("--json") }).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`  ✗ gaon hub 실패: ${msg}\n`);
+            process.exitCode = 1;
+        });
+        return;
+    }
+    // `gaon work` — 워커 프로세스(§7 M7). 잡·리스너·스케줄·아웃박스 조립.
+    // 시그널에 graceful drain 후 종료.
+    if (argv[0] === "work") {
+        void runWorkCommand({ json: argv.includes("--json") }).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`  ✗ gaon work 실패: ${msg}\n`);
+            process.exitCode = 1;
+        });
+        return;
+    }
+    // `gaon jobs` — DLQ 조회·재적재(§7 M7). list --failed | retry <id>.
+    if (argv[0] === "jobs") {
+        void runJobsCommand(argv.slice(1), { json: argv.includes("--json") })
+            .then((code) => {
+            process.exitCode = code;
+        })
+            .catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`  ✗ gaon jobs 실패: ${msg}\n`);
+            process.exitCode = 1;
+        });
+        return;
+    }
     // `gaon g auth` — 인증 스캐폴드 제너레이터(§7 M5). 다른 제너레이터는 후속.
     if (argv[0] === "g" || argv[0] === "generate") {
         if (argv[1] === "auth") {

package/dist/jobs.d.ts

@@ -0,0 +1,7 @@
+export interface JobsCommandOptions {
+    readonly json?: boolean;
+    /** NATS 접속지. 생략 시 GAON_NATS_URL, 그다음 기본(4222). */
+    readonly natsUrl?: string;
+}
+/** `gaon jobs ...` 진입점. 종료 코드를 돌려준다(0 성공 · 1 실패). */
+export declare function runJobsCommand(argv: readonly string[], opts?: JobsCommandOptions): Promise<number>;

package/dist/jobs.js

@@ -0,0 +1,76 @@
+/**
+ * @gaonjs/cli · `gaon jobs` — DLQ 조회·재적재 (§7 · M7 · line 886~887)
+ *
+ * 최대 재시도를 소진해 DLQ 로 간 잡을 운영자가 확인하고 재실행한다:
+ *   gaon jobs list --failed      실패 잡 목록(최신순)
+ *   gaon jobs retry <id>         DLQ 잡을 잡 큐로 재적재
+ * 모든 명령과 같이 `--json` 을 제공한다.
+ */
+import { connectNats, listDlq, retryDlq } from '@gaonjs/async';
+function fmtTime(ms) {
+    return new Date(ms).toISOString();
+}
+function renderList(entries) {
+    if (entries.length === 0)
+        return '  DLQ 가 비어 있습니다 — 실패한 잡이 없습니다.';
+    const lines = [`  실패 잡 ${entries.length}건 (최신순):`, ''];
+    for (const e of entries) {
+        lines.push(`  ${e.id}  ${e.name}  (시도 ${e.attempts}회 · ${fmtTime(e.failedAt)})`);
+        lines.push(`     ↳ ${e.error}`);
+    }
+    lines.push('');
+    lines.push('  재적재: gaon jobs retry <id>');
+    return lines.join('\n');
+}
+/** `gaon jobs ...` 진입점. 종료 코드를 돌려준다(0 성공 · 1 실패). */
+export async function runJobsCommand(argv, opts = {}) {
+    const json = opts.json ?? argv.includes('--json');
+    const sub = argv[0];
+    if (sub === 'list') {
+        const failedOnly = argv.includes('--failed');
+        if (!failedOnly) {
+            process.stderr.write(`  ✗ gaon jobs list 는 현재 --failed(DLQ) 만 지원합니다.\n` +
+                `  → gaon jobs list --failed\n`);
+            return 1;
+        }
+        const nats = await connectNats({ servers: opts.natsUrl, name: 'jobs-cli' });
+        try {
+            const entries = await listDlq(nats);
+            if (json)
+                process.stdout.write(JSON.stringify({ failed: entries }, null, 2) + '\n');
+            else
+                process.stdout.write(renderList(entries) + '\n');
+            return 0;
+        }
+        finally {
+            await nats.close();
+        }
+    }
+    if (sub === 'retry') {
+        const id = argv[1];
+        if (!id || id.startsWith('--')) {
+            process.stderr.write(`  ✗ 재적재할 잡 id 가 필요합니다.\n  → gaon jobs retry <id>\n`);
+            return 1;
+        }
+        const nats = await connectNats({ servers: opts.natsUrl, name: 'jobs-cli' });
+        try {
+            const entry = await retryDlq(nats, id);
+            if (json)
+                process.stdout.write(JSON.stringify({ retried: entry }, null, 2) + '\n');
+            else
+                process.stdout.write(`  ↺ 재적재 완료 — ${entry.name} (id ${entry.id})\n`);
+            return 0;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`  ✗ ${msg}\n`);
+            return 1;
+        }
+        finally {
+            await nats.close();
+        }
+    }
+    process.stderr.write(`  ✗ 알 수 없는 jobs 명령: ${sub ?? '(없음)'}\n` +
+        `  → gaon jobs list --failed | gaon jobs retry <id>\n`);
+    return 1;
+}

package/dist/work.d.ts

@@ -0,0 +1,24 @@
+export interface WorkCommandOptions {
+    readonly json?: boolean;
+    /** NATS 접속지. 생략 시 GAON_NATS_URL, 그다음 기본(4222). */
+    readonly natsUrl?: string;
+    /** 도메인 루트(domain/ 의 부모). 기본 cwd. */
+    readonly root?: string;
+    /** 아웃박스 릴레이용 DB URL. 생략 시 GAON_DATABASE_URL, 없으면 릴레이 미기동. */
+    readonly databaseUrl?: string;
+    /** 큐 기본 동시성. */
+    readonly concurrency?: number;
+    /** ack 대기(ms). 생략 시 GAON_WORKER_ACK_WAIT_MS. */
+    readonly ackWaitMs?: number;
+    /** graceful drain 상한(ms). 생략 시 GAON_WORKER_DRAIN_MS. */
+    readonly drainTimeoutMs?: number;
+    /** 시그널 등록·해제(테스트 주입). 기본 process. */
+    readonly signals?: {
+        on(sig: 'SIGINT' | 'SIGTERM', fn: () => void): void;
+        off(sig: 'SIGINT' | 'SIGTERM', fn: () => void): void;
+    };
+}
+/**
+ * 워커를 띄우고 시그널까지 살려 둔다. 반환 프라미스는 graceful 종료 시 resolve.
+ */
+export declare function runWorkCommand(opts?: WorkCommandOptions): Promise<void>;

package/dist/work.js

@@ -0,0 +1,113 @@
+/**
+ * @gaonjs/cli · `gaon work` — 워커 프로세스 (§7 · M7)
+ *
+ * 운영 프로세스 3종(serve · work · hub) 중 하나. 도메인의 잡·리스너·스케줄·
+ * 아웃박스를 한 프로세스에 조립해 돌린다(@gaonjs/async runWork). 개발
+ * 모드는 `gaon dev` 가 워커를 내장 실행하므로 이 명령은 운영 배치용이다.
+ *
+ * 종료 시그널(SIGTERM·SIGINT)에 graceful drain — 스케줄러 리더 반납 →
+ * 릴레이·리스너·워커 순으로 내리고, 진행 중 잡은 상한까지 기다린다. 모든
+ * 명령과 같이 `--json` 을 제공한다.
+ */
+import { hostname } from 'node:os';
+import { connectNats, runWork } from '@gaonjs/async';
+import { createDb } from '@gaonjs/data';
+import { loadDomain } from './domain.js';
+/** DB URL 에서 어댑터를 추정한다(postgres·mysql). */
+function dbConfigFromUrl(url) {
+    if (url.startsWith('mysql://') || url.startsWith('mariadb://')) {
+        return { adapter: 'mysql', url, poolMax: 4 };
+    }
+    return { adapter: 'postgres', url, poolMax: 4 };
+}
+/** 환경변수를 정수로 파싱(미설정·비정상 시 undefined). */
+function envInt(name) {
+    const raw = process.env[name];
+    if (raw == null || raw === '')
+        return undefined;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : undefined;
+}
+function emitHuman(e) {
+    switch (e.kind) {
+        case 'ready':
+            return `  gaon work · 준비 — 잡 ${e.jobs} · 리스너 ${e.listeners} · 스케줄 ${e.scheduled}`;
+        case 'scheduler':
+            if (e.event.kind === 'leader')
+                return e.event.leader ? '  ▶ 스케줄러 리더 — 틱 발행 시작' : '  · 스케줄러 대기(standby)';
+            if (e.event.kind === 'fired')
+                return `  ⏰ 스케줄 발행 — ${e.event.label}`;
+            return undefined;
+        case 'worker':
+            if (e.event.kind === 'dead')
+                return `  ✗ 잡 DLQ — ${e.event.job} (${e.event.error})`;
+            return undefined;
+        case 'relay':
+            return `  ↪ 아웃박스 릴레이 — ${e.count}건 발행`;
+        default:
+            return undefined;
+    }
+}
+/**
+ * 워커를 띄우고 시그널까지 살려 둔다. 반환 프라미스는 graceful 종료 시 resolve.
+ */
+export async function runWorkCommand(opts = {}) {
+    const json = opts.json ?? false;
+    const signals = opts.signals ?? process;
+    const root = opts.root ?? process.cwd();
+    const id = `${hostname()}#${process.pid}`;
+    const emit = (e) => {
+        if (json) {
+            process.stdout.write(JSON.stringify(e) + '\n');
+        }
+        else {
+            const line = emitHuman(e);
+            if (line)
+                process.stdout.write(line + '\n');
+        }
+    };
+    const nats = await connectNats({ servers: opts.natsUrl, name: `work@${id}` });
+    let db;
+    const dbUrl = opts.databaseUrl ?? process.env.GAON_DATABASE_URL;
+    if (dbUrl)
+        db = createDb(dbConfigFromUrl(dbUrl));
+    const domain = await loadDomain(root);
+    let work;
+    try {
+        work = await runWork({
+            nats,
+            id,
+            db,
+            schedule: domain.schedule,
+            concurrency: opts.concurrency,
+            ackWaitMs: opts.ackWaitMs ?? envInt('GAON_WORKER_ACK_WAIT_MS'),
+            drainTimeoutMs: opts.drainTimeoutMs ?? envInt('GAON_WORKER_DRAIN_MS'),
+            onEvent: emit,
+        });
+    }
+    catch (err) {
+        if (db)
+            await db.destroy().catch(() => { });
+        await nats.close();
+        throw err;
+    }
+    await new Promise((resolve) => {
+        const stop = () => {
+            signals.off('SIGINT', stop);
+            signals.off('SIGTERM', stop);
+            void (async () => {
+                await work.stop();
+                if (db)
+                    await db.destroy().catch(() => { });
+                await nats.close();
+                if (json)
+                    process.stdout.write(JSON.stringify({ kind: 'stopped' }) + '\n');
+                else
+                    process.stdout.write('  gaon work · 종료\n');
+                resolve();
+            })();
+        };
+        signals.on('SIGINT', stop);
+        signals.on('SIGTERM', stop);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaonjs/cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Gaon CLI 구현: 제너레이터·스캐폴딩·로드맵 출력 (M1 스텁)",
   "type": "module",
   "license": "MIT",
@@ -24,9 +24,10 @@
     "README.md"
   ],
   "dependencies": {
+    "@gaonjs/async": "0.2.1",
     "@gaonjs/core": "0.1.3",
     "@gaonjs/data": "0.2.2",
-    "@gaonjs/web": "0.2.0"
+    "@gaonjs/web": "0.2.2"
   },
   "scripts": {
     "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json && node -e \"require('fs').cpSync('src/templates','dist/templates',{recursive:true})\""