soja-cli 1.4.0

package/dist/application/timeline.js

@@ -0,0 +1,83 @@
+import { PRIORITY_LABELS, STATUS_LABELS, TYPE_LABELS } from '../domain/task.js';
+/** Merges activity and comments into one chronological timeline. */
+export function buildTimeline(activity, comments, lookups) {
+    const user = (id) => (id ? (lookups.users.get(id) ?? null) : null);
+    const entries = [];
+    for (const item of activity) {
+        // The comment itself is a richer entry than "added a comment".
+        if (item.type === 'comment_added')
+            continue;
+        entries.push({ kind: 'event', id: item.id, at: item.createdAt, actor: user(item.userId), text: describe(item, lookups), event: { type: item.type, metadata: item.metadata } });
+    }
+    for (const comment of comments) {
+        entries.push({ kind: 'comment', id: comment.id, at: comment.createdAt, actor: user(comment.userId), body: comment.body });
+    }
+    // Stable sort keeps insertion order for entries written in the same millisecond.
+    return entries.sort((a, b) => a.at.getTime() - b.at.getTime());
+}
+export function describe(item, lookups) {
+    const who = (id) => (id ? `@${lookups.users.get(id)?.username ?? 'someone'}` : 'nobody');
+    const project = (id) => (id ? (lookups.projects.get(id)?.name ?? 'a removed project') : null);
+    switch (item.type) {
+        case 'task_created':
+            return 'created the task';
+        case 'status_changed':
+            return `moved ${STATUS_LABELS[item.metadata.from]} → ${STATUS_LABELS[item.metadata.to]}`;
+        case 'task_completed':
+            return `completed it · ${STATUS_LABELS[item.metadata.from]} → Done`;
+        case 'task_reopened':
+            return `reopened it · ${STATUS_LABELS[item.metadata.from]} → ${STATUS_LABELS[item.metadata.to]}`;
+        case 'priority_changed':
+            return `set priority ${PRIORITY_LABELS[item.metadata.from]} → ${PRIORITY_LABELS[item.metadata.to]}`;
+        case 'assigned':
+            return item.metadata.from ? `reassigned ${who(item.metadata.from)} → ${who(item.metadata.to)}` : `assigned ${who(item.metadata.to)}`;
+        case 'unassigned':
+            return `unassigned ${who(item.metadata.from)}`;
+        case 'project_changed': {
+            const to = project(item.metadata.to);
+            return to ? `moved it to ${to}` : 'removed it from its project';
+        }
+        case 'comment_added':
+            return 'added a comment';
+        case 'git_committed':
+            return `committed ${item.metadata.hash.slice(0, 7)} “${item.metadata.subject}”`;
+        case 'git_merged':
+            return `merged ${item.metadata.branch} into ${item.metadata.into}`;
+        case 'git_branch_deleted':
+            return `deleted branch ${item.metadata.branch}${item.metadata.merged ? '' : ' (unmerged)'}`;
+        case 'git_pushed':
+            return `pushed ${item.metadata.branch} to ${item.metadata.remote}`;
+        case 'git_merge_detected':
+            return `merge into ${item.metadata.into} detected (done outside SOJA)`;
+        case 'pr_opened':
+            return `opened a pull request ${item.metadata.url}`;
+        case 'task_archived':
+            return 'archived the task';
+        case 'task_unarchived':
+            return 'restored the task from the archive';
+        case 'pr_merged':
+            return item.metadata.via === 'soja'
+                ? `merged PR #${item.metadata.number} into ${item.metadata.into} on GitHub`
+                : `PR #${item.metadata.number} was merged into ${item.metadata.into} on GitHub`;
+        case 'pr_checks_failed':
+            return `checks failed on PR #${item.metadata.number} (${item.metadata.sha.slice(0, 7)}): ${item.metadata.checks.join(', ') || 'see GitHub'}`;
+        case 'task_updated': {
+            const { field, from, to } = item.metadata;
+            switch (field) {
+                case 'title':
+                    return `renamed it to “${to ?? ''}”`;
+                case 'description':
+                    return to ? 'edited the description' : 'cleared the description';
+                case 'type':
+                    return `changed type ${typeLabel(from)} → ${typeLabel(to)}`;
+                case 'requester':
+                    return to ? `set requester to ${to}` : 'cleared the requester';
+                case 'branch':
+                    return to ? `linked branch ${to}` : 'unlinked the branch';
+            }
+        }
+    }
+}
+function typeLabel(value) {
+    return value && value in TYPE_LABELS ? TYPE_LABELS[value] : (value ?? '—');
+}

package/dist/application/types.js

@@ -0,0 +1 @@
+export {};

package/dist/application/validation.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { ValidationError } from '../domain/errors.js';
+/** Trimmed optional text: blank becomes null, absent stays undefined. */
+export const optionalText = (max) => z
+    .string()
+    .trim()
+    .max(max, { error: `Keep it under ${max} characters.` })
+    .nullable()
+    .optional()
+    .transform((value) => (value === undefined ? undefined : value || null));
+export const usernameSchema = z
+    .string()
+    .trim()
+    .toLowerCase()
+    .regex(/^[a-z0-9][a-z0-9._-]{0,31}$/, {
+    error: 'Usernames use lowercase letters, numbers, dots, dashes or underscores (max 32).',
+});
+export const displayNameSchema = z
+    .string()
+    .trim()
+    .min(1, { error: 'A name is required.' })
+    .max(60, { error: 'Keep the name under 60 characters.' });
+export function parseInput(schema, input) {
+    const result = schema.safeParse(input);
+    if (result.success)
+        return result.data;
+    const issue = result.error.issues[0];
+    const field = issue?.path.length ? `${issue.path.join('.')}: ` : '';
+    throw new ValidationError(`${field}${issue?.message ?? 'Invalid input.'}`);
+}

package/dist/bootstrap.js

@@ -0,0 +1,91 @@
+import { FileConfigStore } from './config/config.js';
+import { resolvePaths } from './config/paths.js';
+import { createServices } from './application/services/index.js';
+import { createLocalRepositories } from './data/local/index.js';
+import { openDatabase } from './database/client.js';
+import { runMigrations } from './database/migrate.js';
+import { CliGit } from './git/cli-git.js';
+import { GitConsole } from './git/console.js';
+import { CredentialStore } from './config/credentials.js';
+import { ApiClient } from './data/remote/api-client.js';
+import { createReplicaServices, replicaFile } from './data/sync/index.js';
+import { SojaError } from './domain/errors.js';
+import { BackupService } from './application/services/backup-service.js';
+import { UpdateService } from './application/services/update-service.js';
+import { NpmReleases } from './git/releases.js';
+import { APP_VERSION } from './ui/branding/brand.js';
+import { join } from 'node:path';
+/**
+ * Composition root: the only place that knows the data source is local
+ * SQLite. A remote mode would branch here and hand the same services a
+ * different set of repositories.
+ */
+export async function bootstrap(options = {}) {
+    const paths = options.paths ?? resolvePaths();
+    const config = options.config ?? new FileConfigStore(paths.configFile);
+    const gitConsole = new GitConsole();
+    const git = options.git ?? new CliGit(gitConsole);
+    const loaded = config.load();
+    if (loaded?.mode === 'remote' && loaded.remote && !options.forceLocal) {
+        const credentials = options.credentials ?? new CredentialStore(paths.credentialsFile);
+        const token = credentials.token(loaded.remote.apiUrl);
+        if (!token) {
+            throw new SojaError(`Not signed in to ${loaded.remote.apiUrl}.`, {
+                hint: `Run \`soja login --server ${loaded.remote.apiUrl}\`, or \`soja mode local\` to work locally.`,
+            });
+        }
+        const api = new ApiClient(loaded.remote.apiUrl, token, options.fetch);
+        // The replica is plain SQLite with the local schema plus sync tables.
+        const replica = openDatabase(options.replicaFile ?? replicaFile(paths.dataDir, loaded.remote.apiUrl), { foreignKeys: false });
+        try {
+            await runMigrations(replica);
+        }
+        catch (error) {
+            replica.close();
+            throw error;
+        }
+        const services = createReplicaServices(api, replica, config, git, gitConsole, options.WebSocket, paths.databaseFile, new BackupService({ label: new URL(loaded.remote.apiUrl).host, backupTo: (file) => replica.backupTo(file) }, backupDir(paths)));
+        return {
+            services,
+            paths,
+            close: () => {
+                services.sync.stop();
+                replica.close();
+            },
+        };
+    }
+    const handle = openDatabase(paths.databaseFile);
+    try {
+        await runMigrations(handle);
+    }
+    catch (error) {
+        handle.close();
+        throw error;
+    }
+    const repos = createLocalRepositories(handle, options.clock);
+    const services = createServices(repos, config, {
+        backups: new BackupService({ label: 'local', backupTo: (file) => handle.backupTo(file) }, backupDir(paths), options.clock),
+        git,
+        gitConsole,
+        ...(options.clock ? { clock: options.clock } : {}),
+    });
+    return { services, paths, close: () => handle.close() };
+}
+export function backupDir(paths) {
+    return join(paths.dataDir, 'backups');
+}
+/**
+ * The database the current mode uses, for restoring a backup without opening
+ * it: the local one, or the replica of the configured server.
+ */
+export function activeDatabase(paths = resolvePaths(), config = new FileConfigStore(paths.configFile)) {
+    const loaded = config.load();
+    if (loaded?.mode === 'remote' && loaded.remote) {
+        return { file: replicaFile(paths.dataDir, loaded.remote.apiUrl), label: new URL(loaded.remote.apiUrl).host };
+    }
+    return { file: paths.databaseFile, label: 'local' };
+}
+/** Newer SOJA versions, from its GitHub releases (checked at most daily for notices). */
+export function createUpdater(paths = resolvePaths()) {
+    return new UpdateService(new NpmReleases(), APP_VERSION, join(paths.dataDir, 'update-check.json'));
+}

package/dist/cli/commands/access.js

@@ -0,0 +1,60 @@
+import { FileConfigStore } from '../../config/config.js';
+import { CredentialStore } from '../../config/credentials.js';
+import { resolvePaths } from '../../config/paths.js';
+import { ApiClient } from '../../data/remote/api-client.js';
+import { requestAccess } from './account.js';
+import { SojaError, ValidationError } from '../../domain/errors.js';
+import { bold, dim, print, success } from '../output.js';
+import { parseCommand } from './args.js';
+const stores = () => {
+    const paths = resolvePaths();
+    return { config: new FileConfigStore(paths.configFile), credentials: new CredentialStore(paths.credentialsFile) };
+};
+export async function accessCommand(args) {
+    const { positionals } = parseCommand(args, {});
+    const action = positionals[0] ?? 'status';
+    const { config, credentials } = stores();
+    const settings = config.load()?.remote;
+    const token = settings ? credentials.token(settings.apiUrl) : null;
+    if (!settings || !token)
+        throw new SojaError('No hay una sesión GitHub de SOJA guardada.', { hint: 'Ejecuta `soja login --server <url>`.' });
+    const api = new ApiClient(settings.apiUrl, token);
+    if (action === 'status') {
+        const [state, profile] = await Promise.all([
+            api.get('/v1/access-request'),
+            api.get('/v1/profile'),
+        ]);
+        print(`Acceso Online: ${bold(state.status)}${profile.user.isCeo ? ` ${bold('CEO de SOJA')}` : ''}`);
+        if (state.request)
+            print(dim(`Solicitud enviada: ${state.request.submittedAt}`));
+        return;
+    }
+    if (action === 'request') {
+        const { user } = await api.get('/v1/profile');
+        await requestAccess(api, user);
+        return;
+    }
+    if (action === 'approvals') {
+        const result = await api.get('/v1/admin/access-requests');
+        if (!result.requests.length) {
+            print('No hay solicitudes pendientes.');
+            return;
+        }
+        for (const request of result.requests) {
+            print(`${bold(`@${request.username}`)} · ${request.displayName} · ${request.countryCode ?? 'sin país'}`);
+            print(`  ${request.letter} ${dim(`(${request.submittedAt})`)}`);
+            print(`  ID: ${request.id}`);
+        }
+        print(dim('Usa `soja access approve <id>` o `soja access reject <id>`.'));
+        return;
+    }
+    if (action === 'approve' || action === 'reject') {
+        const id = positionals[1];
+        if (!id)
+            throw new ValidationError(`Indica el ID: soja access ${action} <id>`);
+        const result = await api.post(`/v1/admin/access-requests/${id}/${action}`);
+        success(`Solicitud ${result.status}.`);
+        return;
+    }
+    throw new ValidationError('Usa `soja access status|request|approvals|approve <id>|reject <id>`.');
+}

package/dist/cli/commands/account.js

@@ -0,0 +1,203 @@
+import { existsSync } from 'node:fs';
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { FileConfigStore } from '../../config/config.js';
+import { CredentialStore, normalize } from '../../config/credentials.js';
+import { resolvePaths } from '../../config/paths.js';
+import { DEFAULT_SERVER_URL, isSecureServerUrl } from '../../config/server.js';
+import { ApiClient } from '../../data/remote/api-client.js';
+import { SojaError, ValidationError } from '../../domain/errors.js';
+import { symbols } from '../../ui/theme/theme.js';
+import { bold, color, dim, print, success } from '../output.js';
+import { withSession } from '../runtime.js';
+import { parseCommand } from './args.js';
+import { confirmTyped } from '../prompt.js';
+async function ask(question) {
+    if (!stdin.isTTY)
+        throw new ValidationError('El alta de acceso necesita una terminal interactiva.');
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function requestAccess(api, user) {
+    const current = await api.get('/v1/access-request');
+    const countries = await api.get('/v1/auth/countries');
+    const displayName = await ask(`Nombre [${current.profile?.displayName ?? user.displayName}]: `) || current.profile?.displayName || user.displayName;
+    const dateOfBirth = await ask('Fecha de nacimiento (AAAA-MM-DD): ');
+    const letter = await ask('¿Por qué te interesa SOJA? (máximo 100 caracteres): ');
+    if (Array.from(letter).length > 100)
+        throw new ValidationError('La carta no puede superar 100 caracteres.');
+    const search = await ask('País (escribe para filtrar): ');
+    const matches = countries.countries.filter((country) => country.name.toLocaleLowerCase().includes(search.toLocaleLowerCase()));
+    if (!matches.length)
+        throw new ValidationError('No encontré países con ese texto. Ejecuta de nuevo `soja login`.');
+    matches.slice(0, 12).forEach((country, index) => print(`  ${index + 1}. ${country.flag} ${country.name} (${country.code})`));
+    const selected = Number(await ask('Elige el número del país: '));
+    const country = matches[selected - 1];
+    if (!country || selected > 12)
+        throw new ValidationError('Selecciona uno de los países mostrados.');
+    const result = await api.post('/v1/access-request', { displayName, dateOfBirth, countryCode: country.code, letter });
+    print(result.status === 'approved' ? 'Acceso aprobado.' : 'Solicitud enviada. Tu sesión queda limitada hasta que el CEO la apruebe.');
+}
+const stores = () => {
+    const paths = resolvePaths();
+    return { config: new FileConfigStore(paths.configFile), credentials: new CredentialStore(paths.credentialsFile) };
+};
+const sleep = (seconds) => new Promise((resolve) => setTimeout(resolve, seconds * 1000));
+/** `soja login --server <url>`: GitHub device flow through the SOJA server; switches to remote mode. */
+export async function loginCommand(args) {
+    const { values } = parseCommand(args, { server: { type: 'string', short: 's' } });
+    const { config, credentials } = stores();
+    const current = config.load();
+    const server = normalize(values.server ?? current?.remote?.apiUrl ?? DEFAULT_SERVER_URL);
+    if (!isSecureServerUrl(server)) {
+        throw new ValidationError('La URL del servidor SOJA debe usar HTTPS.', { hint: 'HTTP solo se permite en localhost para desarrollo. Usa `soja login --server <url>` para indicar otro servidor.' });
+    }
+    const api = new ApiClient(server, null);
+    const health = await api.get('/v1/health').catch((error) => {
+        throw new SojaError(`${server} does not look like a SOJA server.`, {
+            hint: 'Use the base URL of your soja-backend, e.g. https://soja-backend-production.up.railway.app',
+            cause: error,
+        });
+    });
+    if (health?.status !== 'ok') {
+        throw new SojaError(`${server} does not look like a SOJA server.`, { hint: 'Its /v1/health did not answer {"status":"ok"}.' });
+    }
+    const start = await api.post('/v1/auth/device');
+    print(`${bold('Sign in with GitHub')} ${dim(`(SOJA server ${health.version} at ${server})`)}`);
+    print();
+    print(`  1. Open   ${color('cyan', start.verificationUri)}`);
+    print(`  2. Enter  ${bold(color('green', start.userCode))}`);
+    print();
+    print(dim('Waiting for approval… (ctrl+c to cancel)'));
+    let interval = start.interval;
+    const deadline = Date.now() + start.expiresIn * 1000;
+    while (Date.now() < deadline) {
+        await sleep(interval);
+        const poll = await api.postWithStatus('/v1/auth/device/token', {
+            deviceCode: start.deviceCode,
+        });
+        if (poll.status === 202) {
+            if (poll.body.status === 'slow_down')
+                interval += 5;
+            continue;
+        }
+        if (!poll.body.token || !poll.body.user)
+            throw new SojaError('The server did not return a session.');
+        const signedInUser = poll.body.user;
+        const accountApi = new ApiClient(server, poll.body.token);
+        const account = await accountApi.get('/v1/me');
+        if (account.user.accessStatus !== 'approved') {
+            credentials.save(server, poll.body.token, signedInUser.username);
+            config.save({ parentFolders: [], ...current, mode: 'local', remote: { apiUrl: server, userId: signedInUser.id } });
+            print(`Sesión GitHub iniciada como ${bold(`@${signedInUser.username}`)}. Estado: ${account.user.accessStatus ?? 'pending'}.`);
+            if (account.user.accessStatus !== 'rejected')
+                await requestAccess(accountApi, signedInUser);
+            print(dim('SOJA permanece en modo local hasta la aprobación. Consulta `soja access status`.'));
+            return;
+        }
+        const sameServer = current?.remote?.apiUrl === server;
+        credentials.save(server, poll.body.token, signedInUser.username);
+        config.save({
+            parentFolders: [],
+            ...current,
+            mode: 'remote',
+            remote: {
+                apiUrl: server,
+                userId: signedInUser.id,
+                ...(sameServer && current?.remote?.workspaceId ? { workspaceId: current.remote.workspaceId } : {}),
+            },
+        });
+        success(`Signed in as ${bold(`@${signedInUser.username}`)} ${dim(`on ${server}`)}`);
+        const { workspaces } = account;
+        if (workspaces.length > 1) {
+            workspaces.forEach((workspace, index) => print(`  ${index + 1}. ${workspace.name}`));
+            const choice = Number(await ask('Selecciona el workspace para entrar: '));
+            const workspace = workspaces[choice - 1];
+            if (!workspace)
+                throw new ValidationError('Selecciona un workspace válido.');
+            const saved = config.load();
+            if (!saved?.remote)
+                throw new SojaError('No se pudo guardar el workspace seleccionado.');
+            config.save({ ...saved, remote: { ...saved.remote, workspaceId: workspace.id } });
+        }
+        if (workspaces.length === 0)
+            print(dim('  No workspaces yet. Create one: soja workspace create "Bravos Development"'));
+        else
+            print(dim(`  Workspaces: ${workspaces.map((workspace) => workspace.name).join(', ')}`));
+        print(dim('  SOJA now uses this server. `soja mode local` switches back to your local data.'));
+        // Local work can come along (it is only read, never moved).
+        if (existsSync(resolvePaths().databaseFile))
+            print(dim('  To bring your local projects and tasks to the team: soja import-local'));
+        return;
+    }
+    throw new SojaError('The login code expired before it was approved.', { hint: 'Run `soja login` again.' });
+}
+/** `soja logout`: revokes the session on the server and returns to local mode. */
+export async function logoutCommand() {
+    const { config, credentials } = stores();
+    const current = config.load();
+    const server = current?.remote?.apiUrl;
+    if (!server) {
+        print(dim('Not signed in to any SOJA server.'));
+        return;
+    }
+    const token = credentials.token(server);
+    if (token)
+        await new ApiClient(server, token).post('/v1/auth/logout').catch(() => undefined);
+    credentials.remove(server);
+    if (current)
+        config.save({ ...current, mode: 'local' });
+    success(`Signed out of ${server}. SOJA is back in local mode.`);
+}
+/** `soja account delete`: revokes sessions and anonymizes shared authorship. */
+export async function deleteAccountCommand(args) {
+    const { values } = parseCommand(args, { yes: { type: 'boolean', short: 'y' } });
+    const { config, credentials } = stores();
+    const current = config.load();
+    const server = current?.remote?.apiUrl;
+    const token = server ? credentials.token(server) : null;
+    if (!server || !token)
+        throw new SojaError('No hay una cuenta SOJA Online activa para borrar.', { hint: 'Inicia sesión primero con `soja login`.' });
+    if (!(await confirmTyped('Esto revoca todas tus sesiones y anonimiza tu perfil en el contenido compartido.', 'BORRAR', values.yes)))
+        return print(dim('Cancelado.'));
+    await new ApiClient(server, token).delete('/v1/account');
+    credentials.remove(server);
+    if (current)
+        config.save({ ...current, mode: 'local' });
+    success('Cuenta eliminada. El contenido compartido se conserva con autoría anonimizada.');
+}
+/** `soja mode [local|remote]`: shows or switches where SOJA reads and writes. */
+export async function modeCommand(args) {
+    const { positionals } = parseCommand(args, {});
+    const { config, credentials } = stores();
+    const current = config.load();
+    const target = positionals[0];
+    if (!target) {
+        print(current?.mode === 'remote' ? `remote ${dim(current.remote?.apiUrl ?? '')}` : 'local');
+        return;
+    }
+    if (target !== 'local' && target !== 'remote')
+        throw new ValidationError('Use `soja mode local` or `soja mode remote`.');
+    if (target === 'remote' && (!current?.remote || !credentials.token(current.remote.apiUrl))) {
+        throw new SojaError('No SOJA server to switch to.', { hint: 'Run `soja login --server <url>` first.' });
+    }
+    if (!current)
+        throw new SojaError('SOJA is not set up yet.', { hint: 'Run `soja` once, or `soja login --server <url>`.' });
+    config.save({ ...current, mode: target });
+    success(`SOJA is in ${bold(target)} mode${target === 'remote' ? dim(` (${current.remote?.apiUrl})`) : ''}.`);
+}
+/** `soja whoami` */
+export async function whoamiCommand() {
+    await withSession(async (services, session) => {
+        const where = services.environment.mode === 'remote' ? `remote ${dim(services.environment.server)}` : 'local';
+        print(`${bold(`@${session.user.username}`)} ${dim(session.user.displayName)}`);
+        print(`  ${dim('workspace')} ${session.workspace.name}`);
+        print(`  ${dim('mode')}      ${where}`);
+        print(dim(`  ${symbols.dot} switch with \`soja mode local|remote\``));
+    });
+}

package/dist/cli/commands/args.js

@@ -0,0 +1,27 @@
+import { parseArgs } from 'node:util';
+import { ValidationError } from '../../domain/errors.js';
+/** Strict option parsing with friendly errors instead of Node's stack traces. */
+export function parseCommand(args, options) {
+    try {
+        return parseArgs({ args, options, allowPositionals: true, strict: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message.split(/(?<=\.) /)[0] : 'Invalid arguments.';
+        throw new ValidationError(message ?? 'Invalid arguments.', { hint: 'See `soja --help`.' });
+    }
+}
+export function requireArg(value, what, usage) {
+    if (!value)
+        throw new ValidationError(`Missing ${what}.`, { hint: `Usage: ${usage}` });
+    return value;
+}
+export function oneOf(value, allowed, what) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase().replace(/[-\s]/g, '_');
+    const alias = normalized === 'med' ? 'medium' : normalized;
+    const match = allowed.find((candidate) => candidate === alias);
+    if (!match)
+        throw new ValidationError(`Unknown ${what} “${value}”.`, { hint: `Use one of: ${allowed.join(', ')}.` });
+    return match;
+}

package/dist/cli/commands/backup.js

@@ -0,0 +1,70 @@
+import { BackupService, restoreBackup } from '../../application/services/backup-service.js';
+import { activeDatabase, backupDir } from '../../bootstrap.js';
+import { resolvePaths } from '../../config/paths.js';
+import { ValidationError } from '../../domain/errors.js';
+import { tildify } from '../../utils/text.js';
+import { formatRelative } from '../../utils/time.js';
+import { bold, color, dim, print, success } from '../output.js';
+import { confirm } from '../prompt.js';
+import { withServices } from '../runtime.js';
+import { parseCommand, requireArg } from './args.js';
+/** `soja backup [list | restore <name>]`: copies of the database in use. */
+export async function backupCommand(args) {
+    const [sub, ...rest] = args;
+    if (sub === undefined || sub === 'now' || sub === 'create')
+        return create();
+    if (sub === 'list' || sub === 'ls')
+        return list();
+    if (sub === 'restore')
+        return restore(rest);
+    throw new ValidationError(`Unknown backup command “${sub}”.`, { hint: 'Try: soja backup, soja backup list, soja backup restore <name>.' });
+}
+async function create() {
+    await withServices(async (services) => {
+        const backup = services.backups.create('manual');
+        success(`Backup saved ${dim(`${tildify(backup.path)} · ${size(backup.bytes)}`)}`);
+    });
+}
+async function list() {
+    const backups = lister().list();
+    if (backups.length === 0)
+        return print(dim('No backups yet. SOJA makes one a day when you open it; `soja backup` makes one now.'));
+    for (const backup of backups)
+        print(line(backup));
+    print(dim(`  in ${tildify(backupDir(resolvePaths()))}`));
+}
+async function restore(args) {
+    const { values, positionals } = parseCommand(args, { yes: { type: 'boolean', short: 'y' } });
+    const name = requireArg(positionals[0], 'backup name', 'soja backup restore <name>  (names: soja backup list)');
+    const paths = resolvePaths();
+    const active = activeDatabase(paths);
+    const backup = lister().find(name);
+    print(`${bold('Restore')} ${backup.name} ${dim(`(${formatRelative(backup.createdAt)})`)}`);
+    print(dim(`  It replaces ${tildify(active.file)}. The current state is saved first as a before-restore backup.`));
+    if (active.label !== 'local')
+        print(dim('  In remote mode this is the replica: the next sync brings back what the server has, and keeps your queued changes.'));
+    if (!(await confirm('Restore it?', values.yes)))
+        return print(dim('Cancelled.'));
+    const saved = restoreBackup(backup, active.file, backupDir(paths), active.label);
+    success(`Restored ${backup.name}`);
+    if (saved)
+        print(dim(`  Previous state kept as ${saved.name}`));
+}
+/** Lists without opening the database (restoring needs it closed). */
+function lister() {
+    const paths = resolvePaths();
+    const active = activeDatabase(paths);
+    return new BackupService({
+        label: active.label,
+        backupTo: () => {
+            throw new Error('not used');
+        },
+    }, backupDir(paths));
+}
+function line(backup) {
+    const kind = backup.kind === 'auto' ? dim('daily') : backup.kind === 'manual' ? color('green', 'manual') : color('yellow', 'before restore');
+    return `  ${backup.name.padEnd(58)} ${kind.padEnd(16)} ${dim(`${formatRelative(backup.createdAt)} · ${size(backup.bytes)}`)}`;
+}
+function size(bytes) {
+    return bytes > 1024 * 1024 ? `${(bytes / 1024 / 1024).toFixed(1)} MB` : `${Math.max(1, Math.round(bytes / 1024))} KB`;
+}