@lionrapid/cli 0.2.2 → 0.4.0

package/dist/job-history.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Local record of the sync jobs this machine has queued — `~/.lionrapid/jobs.json`.
+ *
+ * Why a file at all: `sync/batch` answers 202 (queued), so the only proof a push
+ * actually landed is the job's later state. You push, close the terminal, and
+ * come back — without this file the job ids are gone with the scrollback and
+ * there is nothing left to ask the server about.
+ *
+ * Why NOT in `~/.lionrapid/credentials`: different lifetime (history is
+ * disposable, a key is not) and different sensitivity. A corrupt or truncated
+ * history must never cost someone their login, so the two files never share a
+ * parser or a write. Everything here degrades to "no history" instead of
+ * throwing — losing visibility is bad, but failing a push because a cache file
+ * is unreadable is worse.
+ *
+ * The server purges finished non-DLQ jobs after ~1h, so for anything older this
+ * file is the ONLY answer available: a terminal status is recorded when we see
+ * it, and later reads report it from disk without a network call.
+ */
+/**
+ * One queued job, as this machine knew it. `files`/`keys` describe what was in
+ * the batch, so `lionrapid status` can say *what* is at risk without a network
+ * call.
+ */
+export interface JobHistoryEntry {
+    /** Server-assigned job id — the key for `GET /sync/jobs/{id}`. */
+    id: string;
+    /** Server this job was queued on (a machine may push to more than one). */
+    server: string;
+    /**
+     * The project uuid this push resolved to, when one is known.
+     *
+     * Replaces the old free-text `project` label copied from lionrapid.yml —
+     * the field that stamped `tm-frontpage` onto 30 jobs that went elsewhere.
+     * Optional both because older entries carry the label instead and because
+     * the server's project id is itself optional.
+     */
+    projectId?: string;
+    /** Legacy: the free-text label, on entries written before the id existed. */
+    project?: string;
+    namespace: string;
+    /** Source locale of the batch. */
+    locale: string;
+    /** Files whose keys were in this batch (one, unless a file was chunked). */
+    files: string[];
+    /** Keys in the batch. */
+    keys: number;
+    /** ISO timestamp of the push that queued it. */
+    pushedAt: string;
+    /**
+     * Last status seen: the server's own vocabulary (`pending`, `processing`,
+     * `retry_pending`, `completed`, `failed`), or `gone` when the server no
+     * longer knows the job.
+     */
+    status: string;
+    /** ISO timestamp of the last status check against the server. */
+    checkedAt?: string;
+    /** Last error the server reported for this job. */
+    error?: string;
+    /** Why the backend gave up, when it did. */
+    deadLetterReason?: string;
+}
+/** Newest first — the order the file is stored in and the order callers get. */
+export type JobHistory = JobHistoryEntry[];
+/**
+ * Pruning. Both bounds apply on every write, so the file cannot grow forever:
+ *
+ * - 500 entries: a single big push is one job per file per 500-key chunk, so a
+ *   large repo can queue dozens at once. 500 keeps weeks of real use while
+ *   staying a ~100KB file.
+ * - 30 days: the server purges finished jobs after ~1h, so an entry older than
+ *   this can never be re-checked — it is a receipt, and a month-old receipt for
+ *   a push you have long since repeated is not worth carrying.
+ *
+ * Whichever bites first wins; entries are dropped oldest-first.
+ */
+export declare const JOB_HISTORY_MAX_ENTRIES = 500;
+export declare const JOB_HISTORY_MAX_AGE_DAYS = 30;
+/**
+ * True when there is no point asking the server again. `failed` counts: the
+ * server only sets it from its dead-letter path, so a failed job is one it gave
+ * up on. `gone` is ours — the job 404s (unknown id, or purged after retention).
+ */
+export declare function isTerminalJobStatus(status: string): boolean;
+/** Where the history lives: `~/.lionrapid/jobs.json`, beside the credentials file. */
+export declare function defaultJobHistoryPath(): string;
+/**
+ * Read the history, newest first. A missing, unreadable, or corrupt file is
+ * simply "no history" — never an exception, and the next write replaces it.
+ */
+export declare function readJobHistory(path?: string): JobHistory;
+/**
+ * Upsert `entries` (by job id) and write the pruned result. Returns what is now
+ * on disk, newest first. A failed write warns and returns the merged list — a
+ * push must not fail because its receipt could not be saved.
+ */
+export declare function recordJobs(entries: JobHistoryEntry[], path?: string): JobHistory;
+/** A status refresh for one job: everything except its identity may change. */
+export type JobStatusPatch = Pick<JobHistoryEntry, 'id'> & Partial<Pick<JobHistoryEntry, 'status' | 'checkedAt' | 'error' | 'deadLetterReason'>>;
+/**
+ * Fold status updates into the stored entries in a single read-modify-write.
+ * Unknown ids are ignored (the history is not a job database — it only tracks
+ * what this machine pushed).
+ */
+export declare function updateJobStatuses(patches: JobStatusPatch[], path?: string): JobHistory;
+//# sourceMappingURL=job-history.d.ts.map

package/dist/job-history.js

@@ -0,0 +1,163 @@
+/**
+ * Local record of the sync jobs this machine has queued — `~/.lionrapid/jobs.json`.
+ *
+ * Why a file at all: `sync/batch` answers 202 (queued), so the only proof a push
+ * actually landed is the job's later state. You push, close the terminal, and
+ * come back — without this file the job ids are gone with the scrollback and
+ * there is nothing left to ask the server about.
+ *
+ * Why NOT in `~/.lionrapid/credentials`: different lifetime (history is
+ * disposable, a key is not) and different sensitivity. A corrupt or truncated
+ * history must never cost someone their login, so the two files never share a
+ * parser or a write. Everything here degrades to "no history" instead of
+ * throwing — losing visibility is bad, but failing a push because a cache file
+ * is unreadable is worse.
+ *
+ * The server purges finished non-DLQ jobs after ~1h, so for anything older this
+ * file is the ONLY answer available: a terminal status is recorded when we see
+ * it, and later reads report it from disk without a network call.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homeDir } from './config.js';
+/**
+ * Pruning. Both bounds apply on every write, so the file cannot grow forever:
+ *
+ * - 500 entries: a single big push is one job per file per 500-key chunk, so a
+ *   large repo can queue dozens at once. 500 keeps weeks of real use while
+ *   staying a ~100KB file.
+ * - 30 days: the server purges finished jobs after ~1h, so an entry older than
+ *   this can never be re-checked — it is a receipt, and a month-old receipt for
+ *   a push you have long since repeated is not worth carrying.
+ *
+ * Whichever bites first wins; entries are dropped oldest-first.
+ */
+export const JOB_HISTORY_MAX_ENTRIES = 500;
+export const JOB_HISTORY_MAX_AGE_DAYS = 30;
+/** Statuses the server never leaves, plus the CLI's own `gone`. */
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'gone']);
+/**
+ * True when there is no point asking the server again. `failed` counts: the
+ * server only sets it from its dead-letter path, so a failed job is one it gave
+ * up on. `gone` is ours — the job 404s (unknown id, or purged after retention).
+ */
+export function isTerminalJobStatus(status) {
+    return TERMINAL_STATUSES.has(status);
+}
+/** Where the history lives: `~/.lionrapid/jobs.json`, beside the credentials file. */
+export function defaultJobHistoryPath() {
+    return join(homeDir(), '.lionrapid', 'jobs.json');
+}
+/** Paths already warned about this process — an unreadable history warns once. */
+const warned = new Set();
+function warnOnce(path, detail) {
+    if (warned.has(path))
+        return;
+    warned.add(path);
+    console.error(`warning: could not use the push history at ${path} (${detail})`);
+}
+function isEntry(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const e = value;
+    return typeof e['id'] === 'string' && e['id'].length > 0 && typeof e['pushedAt'] === 'string';
+}
+/**
+ * Read the history, newest first. A missing, unreadable, or corrupt file is
+ * simply "no history" — never an exception, and the next write replaces it.
+ */
+export function readJobHistory(path = defaultJobHistoryPath()) {
+    if (!existsSync(path))
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (err) {
+        warnOnce(path, err instanceof Error ? err.message : String(err));
+        return [];
+    }
+    const jobs = parsed !== null && typeof parsed === 'object' && Array.isArray(parsed.jobs)
+        ? parsed.jobs
+        : [];
+    return sortNewestFirst(jobs.filter(isEntry));
+}
+/**
+ * Upsert `entries` (by job id) and write the pruned result. Returns what is now
+ * on disk, newest first. A failed write warns and returns the merged list — a
+ * push must not fail because its receipt could not be saved.
+ */
+export function recordJobs(entries, path = defaultJobHistoryPath()) {
+    if (entries.length === 0)
+        return readJobHistory(path);
+    return mutate(path, (current) => [...entries, ...current]);
+}
+/**
+ * Fold status updates into the stored entries in a single read-modify-write.
+ * Unknown ids are ignored (the history is not a job database — it only tracks
+ * what this machine pushed).
+ */
+export function updateJobStatuses(patches, path = defaultJobHistoryPath()) {
+    if (patches.length === 0)
+        return readJobHistory(path);
+    const byId = new Map(patches.map((p) => [p.id, p]));
+    return mutate(path, (current) => current.map((entry) => {
+        const patch = byId.get(entry.id);
+        return patch ? { ...entry, ...stripUndefined(patch), id: entry.id } : entry;
+    }));
+}
+/** Read → transform → dedupe → prune → write. The one place that touches the file. */
+function mutate(path, transform) {
+    // Re-read immediately before writing: two pushes in different terminals
+    // otherwise clobber each other's ids.
+    const next = prune(dedupe(transform(readJobHistory(path))));
+    try {
+        write(path, next);
+    }
+    catch (err) {
+        warnOnce(path, err instanceof Error ? err.message : String(err));
+    }
+    return next;
+}
+/** First occurrence of an id wins — callers pass their fresher entries first. */
+function dedupe(entries) {
+    const seen = new Set();
+    const out = [];
+    for (const entry of entries) {
+        if (seen.has(entry.id))
+            continue;
+        seen.add(entry.id);
+        out.push(entry);
+    }
+    return out;
+}
+function prune(entries) {
+    const cutoff = Date.now() - JOB_HISTORY_MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
+    const fresh = sortNewestFirst(entries).filter((e) => {
+        const at = Date.parse(e.pushedAt);
+        // An unparseable timestamp is kept: dropping a receipt because we cannot
+        // read its clock loses exactly the information the file exists to hold.
+        return Number.isNaN(at) || at >= cutoff;
+    });
+    return fresh.slice(0, JOB_HISTORY_MAX_ENTRIES);
+}
+function sortNewestFirst(entries) {
+    return [...entries].sort((a, b) => (a.pushedAt < b.pushedAt ? 1 : a.pushedAt > b.pushedAt ? -1 : 0));
+}
+function stripUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+}
+/**
+ * Write via a temp file + rename so a crash mid-write leaves the previous
+ * history intact rather than a half-written one. Same 0700/0600 permissions as
+ * the credentials file: this records project names and file paths.
+ */
+function write(path, entries) {
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const tmp = join(dir, `.jobs.${process.pid}.tmp`);
+    const body = `${JSON.stringify({ version: 1, jobs: entries }, null, 2)}\n`;
+    writeFileSync(tmp, body, { mode: 0o600 });
+    renameSync(tmp, path);
+}
+//# sourceMappingURL=job-history.js.map

package/dist/lockfile.d.ts

@@ -0,0 +1,90 @@
+/**
+ * `.lionrapid/lock.json` — the record of what the SERVER last said.
+ *
+ * Today `push` re-uploads every string every time: 653 on the first run, 653
+ * on the second. And there is no way to know a translator edited a target
+ * locally, so `pull` would silently overwrite it. Both are the same missing
+ * thing — no record of the last known server state — and one mechanism buys
+ * incremental push, conflict detection, and a CI action that does not
+ * re-translate the world on every run.
+ *
+ * COMMITTED to version control, like `package-lock.json`. Per-machine would
+ * mean CI and a laptop disagree about what changed, which is exactly the
+ * disagreement an automated pipeline cannot tolerate.
+ *
+ * Two fields, two owners, and the split matters:
+ *   `sourceHash`       what we last SENT for a source key (push writes it)
+ *   `serverUpdatedAt`  when the server last told us about a row (PULL ONLY)
+ * Push must never fabricate `serverUpdatedAt`, or the lock would claim
+ * knowledge of a server state it never observed.
+ */
+import { type ContentUnit } from '@lionrapid/core';
+/** Where the lock lives, relative to the project root. */
+export declare const LOCKFILE_PATH: string;
+/** The only shape this CLI writes. A higher number is a newer CLI's file. */
+export declare const LOCK_VERSION = 1;
+export interface LockTarget {
+    /** Hash of the target value as the server last gave it to us. */
+    hash: string;
+    /** When the server last reported this row. Written by `pull`, never by `push`. */
+    serverUpdatedAt?: string;
+}
+export interface LockEntry {
+    /** Hash of the source text this key was last known to carry. */
+    sourceHash: string;
+    /** When the server last reported the source row (pull-only). */
+    serverUpdatedAt?: string;
+    /** Per-target-locale state, keyed by locale. */
+    targets?: Record<string, LockTarget>;
+}
+export interface Lock {
+    version: number;
+    /**
+     * The project this lock was written against. A lock from another project
+     * computes a nonsense diff, so a mismatch stops the run.
+     *
+     * OPTIONAL because nothing serves a project id yet — it arrives with the
+     * server's `projectId` on project-config (spec C4/S2). Until then locks
+     * carry none and the check simply has nothing to compare.
+     */
+    projectId?: string;
+    /** `namespace:key` → what we last knew. */
+    entries: Record<string, LockEntry>;
+}
+export interface ReadLockOptions {
+    /** The config's project id, when one is known, for the mismatch guard. */
+    projectId?: string;
+}
+/** A lock that knows nothing. Distinct from "everything changed" — see `readLock`. */
+export declare function emptyLock(): Lock;
+/**
+ * Hash a source value.
+ *
+ * Reuses `generateAutoKey`, the md5-12 already shared by core, edge, WordPress
+ * TS and WordPress PHP and pinned by `parity-vectors.json`. A second hash
+ * would be a second thing to keep in lockstep for no gain. Inline markup is
+ * part of the value, so the indexed tags travel into the hash — a bold run
+ * added around a word is a real change to push.
+ */
+export declare function hashSource(value: ContentUnit): string;
+/** The lock's key for a row: the coordinates a push actually addresses. */
+export declare function lockKey(namespace: string, key: string): string;
+/**
+ * Read the lock, or an empty one when there is no file.
+ *
+ * A MISSING lock is "we know nothing" (a backfill), never "everything
+ * changed". A CORRUPT lock throws: silently rebuilding one would mark local
+ * edits as server-known and lose them on the very next pull, which is the
+ * failure this file exists to prevent.
+ */
+export declare function readLock(cwd: string, opts?: ReadLockOptions): Lock;
+/**
+ * Write the lock, keys sorted.
+ *
+ * Sorted because this file is committed: a lock that reorders itself produces
+ * a diff on every run and stops being reviewable, which is most of the reason
+ * to commit it. Written via temp+rename so an interrupted run cannot leave a
+ * half-written lock that the next run would refuse to parse.
+ */
+export declare function writeLock(cwd: string, lock: Lock): void;
+//# sourceMappingURL=lockfile.d.ts.map

package/dist/lockfile.js

@@ -0,0 +1,110 @@
+/**
+ * `.lionrapid/lock.json` — the record of what the SERVER last said.
+ *
+ * Today `push` re-uploads every string every time: 653 on the first run, 653
+ * on the second. And there is no way to know a translator edited a target
+ * locally, so `pull` would silently overwrite it. Both are the same missing
+ * thing — no record of the last known server state — and one mechanism buys
+ * incremental push, conflict detection, and a CI action that does not
+ * re-translate the world on every run.
+ *
+ * COMMITTED to version control, like `package-lock.json`. Per-machine would
+ * mean CI and a laptop disagree about what changed, which is exactly the
+ * disagreement an automated pipeline cannot tolerate.
+ *
+ * Two fields, two owners, and the split matters:
+ *   `sourceHash`       what we last SENT for a source key (push writes it)
+ *   `serverUpdatedAt`  when the server last told us about a row (PULL ONLY)
+ * Push must never fabricate `serverUpdatedAt`, or the lock would claim
+ * knowledge of a server state it never observed.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { generateAutoKey } from '@lionrapid/core';
+import { ConfigError } from './config.js';
+/** Where the lock lives, relative to the project root. */
+export const LOCKFILE_PATH = join('.lionrapid', 'lock.json');
+/** The only shape this CLI writes. A higher number is a newer CLI's file. */
+export const LOCK_VERSION = 1;
+/** A lock that knows nothing. Distinct from "everything changed" — see `readLock`. */
+export function emptyLock() {
+    return { version: LOCK_VERSION, entries: {} };
+}
+/**
+ * Hash a source value.
+ *
+ * Reuses `generateAutoKey`, the md5-12 already shared by core, edge, WordPress
+ * TS and WordPress PHP and pinned by `parity-vectors.json`. A second hash
+ * would be a second thing to keep in lockstep for no gain. Inline markup is
+ * part of the value, so the indexed tags travel into the hash — a bold run
+ * added around a word is a real change to push.
+ */
+export function hashSource(value) {
+    const styles = Object.keys(value.styles ?? {}).length > 0 ? JSON.stringify(value.styles) : '';
+    return generateAutoKey(styles ? `${value.text}
${styles}` : value.text);
+}
+/** The lock's key for a row: the coordinates a push actually addresses. */
+export function lockKey(namespace, key) {
+    return `${namespace}:${key}`;
+}
+/**
+ * Read the lock, or an empty one when there is no file.
+ *
+ * A MISSING lock is "we know nothing" (a backfill), never "everything
+ * changed". A CORRUPT lock throws: silently rebuilding one would mark local
+ * edits as server-known and lose them on the very next pull, which is the
+ * failure this file exists to prevent.
+ */
+export function readLock(cwd, opts = {}) {
+    const path = join(cwd, LOCKFILE_PATH);
+    if (!existsSync(path))
+        return emptyLock();
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (err) {
+        throw new ConfigError(`Could not parse ${LOCKFILE_PATH}: ${err instanceof Error ? err.message : String(err)}.\n` +
+            `  Delete ${LOCKFILE_PATH} and run \`lionrapid pull\` to rebuild it from the server.`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new ConfigError(`${LOCKFILE_PATH} is not a JSON object.\n` +
+            `  Delete ${LOCKFILE_PATH} and run \`lionrapid pull\` to rebuild it.`);
+    }
+    const lock = parsed;
+    if (typeof lock.version !== 'number' || lock.version > LOCK_VERSION) {
+        throw new ConfigError(`${LOCKFILE_PATH} is version ${String(lock.version)}, but this CLI understands ${LOCK_VERSION}.\n` +
+            '  Upgrade @lionrapid/cli, or delete the file and re-pull.');
+    }
+    if (opts.projectId && lock.projectId && lock.projectId !== opts.projectId) {
+        throw new ConfigError(`${LOCKFILE_PATH} belongs to project ${lock.projectId}, but this config is ${opts.projectId}.\n` +
+            '  A lock from another project would compute a meaningless diff — delete it and re-pull.');
+    }
+    return {
+        version: lock.version,
+        ...(lock.projectId ? { projectId: lock.projectId } : {}),
+        entries: lock.entries !== null && typeof lock.entries === 'object' && !Array.isArray(lock.entries)
+            ? lock.entries
+            : {},
+    };
+}
+/**
+ * Write the lock, keys sorted.
+ *
+ * Sorted because this file is committed: a lock that reorders itself produces
+ * a diff on every run and stops being reviewable, which is most of the reason
+ * to commit it. Written via temp+rename so an interrupted run cannot leave a
+ * half-written lock that the next run would refuse to parse.
+ */
+export function writeLock(cwd, lock) {
+    const path = join(cwd, LOCKFILE_PATH);
+    const sorted = {};
+    for (const key of Object.keys(lock.entries).sort())
+        sorted[key] = lock.entries[key];
+    const body = `${JSON.stringify({ ...lock, entries: sorted }, null, 2)}\n`;
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, body);
+    renameSync(tmp, path);
+}
+//# sourceMappingURL=lockfile.js.map

package/dist/time.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Timestamp handling for values that come off the wire.
+ *
+ * tm-server serialises with `datetime.isoformat()` and its clock is UTC, so a
+ * job's `completed_at` arrives as `2026-08-07T16:35:24.248993` — an ISO
+ * date-time with NO timezone designator. `Date.parse` reads that as LOCAL
+ * time, which on a UTC+3 machine rendered every server timestamp three hours
+ * early: `lionrapid status` showed a job finishing three hours before the push
+ * that created it.
+ *
+ * The rule is about the STRING, not about tm-server: no offset means UTC, an
+ * offset means exactly what it says. Appending `Z` unconditionally would fix
+ * today and break the day the server starts sending real offsets.
+ */
+/**
+ * Epoch milliseconds for a server timestamp, or null if it is absent or
+ * unparseable. An offset-less date-time is read as UTC; anything already
+ * carrying a zone is passed through untouched.
+ */
+export declare function parseServerTime(value: string | undefined | null): number | null;
+/**
+ * `2026-08-07 19:35:24` in the reader's own timezone. A value we cannot parse
+ * is echoed verbatim rather than rendered as "Invalid Date" — showing the raw
+ * string at least tells you what the server said.
+ */
+export declare function formatLocal(value: string | undefined | null): string;
+//# sourceMappingURL=time.d.ts.map

package/dist/time.js

@@ -0,0 +1,53 @@
+/**
+ * Timestamp handling for values that come off the wire.
+ *
+ * tm-server serialises with `datetime.isoformat()` and its clock is UTC, so a
+ * job's `completed_at` arrives as `2026-08-07T16:35:24.248993` — an ISO
+ * date-time with NO timezone designator. `Date.parse` reads that as LOCAL
+ * time, which on a UTC+3 machine rendered every server timestamp three hours
+ * early: `lionrapid status` showed a job finishing three hours before the push
+ * that created it.
+ *
+ * The rule is about the STRING, not about tm-server: no offset means UTC, an
+ * offset means exactly what it says. Appending `Z` unconditionally would fix
+ * today and break the day the server starts sending real offsets.
+ */
+/** True when the time part already carries `Z` or a `±HH:MM` / `±HHMM` offset. */
+function hasTimezone(value) {
+    const timePart = value.slice(value.indexOf('T') + 1);
+    return /[Zz]$/.test(timePart) || /[+-]\d{2}:?\d{2}$/.test(timePart);
+}
+/**
+ * Epoch milliseconds for a server timestamp, or null if it is absent or
+ * unparseable. An offset-less date-time is read as UTC; anything already
+ * carrying a zone is passed through untouched.
+ */
+export function parseServerTime(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    // A date-only value has no time to misinterpret — JS already reads those as
+    // UTC, and appending `Z` would make it unparseable.
+    const naive = trimmed.includes('T') && !hasTimezone(trimmed);
+    const ms = Date.parse(naive ? `${trimmed}Z` : trimmed);
+    return Number.isNaN(ms) ? null : ms;
+}
+/**
+ * `2026-08-07 19:35:24` in the reader's own timezone. A value we cannot parse
+ * is echoed verbatim rather than rendered as "Invalid Date" — showing the raw
+ * string at least tells you what the server said.
+ */
+export function formatLocal(value) {
+    if (!value)
+        return '—';
+    const ms = parseServerTime(value);
+    if (ms === null)
+        return value;
+    const d = new Date(ms);
+    const pad = (n) => String(n).padStart(2, '0');
+    return (`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
+        `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`);
+}
+//# sourceMappingURL=time.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lionrapid/cli",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "LionRapid CLI — sync translation files (iOS, Android, Flutter, JSON, YAML, PO) with the LionRapid backend",
   "type": "module",
   "main": "./dist/index.js",