soja-cli 1.4.0

package/dist/cli/commands/project.js

@@ -0,0 +1,108 @@
+import { existsSync } from 'node:fs';
+import { 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, requireArg } from './args.js';
+import { tildify } from '../../utils/text.js';
+export async function projectCommand(args) {
+    const [sub, ...rest] = args;
+    if (sub === undefined || sub === 'list' || sub === 'ls')
+        return list();
+    if (sub === 'create' || sub === 'new' || sub === 'add')
+        return create(rest);
+    if (sub === 'link')
+        return link(rest);
+    if (sub === 'unlink')
+        return unlink(rest);
+    if (sub === 'edit')
+        return edit(rest);
+    throw new ValidationError(`Unknown project command “${sub}”.`, { hint: 'Try: list, create, edit, link, unlink.' });
+}
+async function list() {
+    await withSession(async (services, session) => {
+        const projects = await services.projects.list(session);
+        print(`${bold('PROJECTS')}  ${dim(session.workspace.name)}`);
+        print();
+        if (projects.length === 0) {
+            print(dim('  No projects yet. Add one with `soja project create <name>`.'));
+            return;
+        }
+        const width = Math.max(...projects.map((project) => project.name.length)) + 3;
+        for (const project of projects) {
+            const extra = [
+                project.counts.in_progress ? color('yellow', `${project.counts.in_progress} in progress`) : '',
+                project.counts.review ? color('cyan', `${project.counts.review} review`) : '',
+                project.counts.blocked ? color('red', `${project.counts.blocked} blocked`) : '',
+            ].filter(Boolean);
+            print(`  ${dim(project.key.padEnd(8))}${project.name.padEnd(width)}${`${project.active} active`.padEnd(11)}${extra.join(dim(` ${symbols.dot} `))}`);
+            if (project.repositoryPath)
+                print(dim(`  ${' '.repeat(8)}${tildify(project.repositoryPath)}`));
+        }
+    });
+}
+async function create(args) {
+    const { values, positionals } = parseCommand(args, {
+        key: { type: 'string', short: 'k' },
+        description: { type: 'string', short: 'd' },
+        'repo-path': { type: 'string' },
+        'repo-url': { type: 'string' },
+    });
+    const name = requireArg(positionals.join(' ').trim(), 'project name', 'soja project create EnrollBridge --key ENROLL');
+    await withSession(async (services, session) => {
+        const project = await services.projects.create(session, {
+            name,
+            ...(values.key ? { key: values.key } : {}),
+            description: values.description ?? null,
+            repositoryPath: values['repo-path'] ?? null,
+            repositoryUrl: values['repo-url'] ?? null,
+        });
+        success(`Created project ${bold(project.name)} ${dim(project.key)}`);
+    });
+}
+async function link(args) {
+    const { positionals } = parseCommand(args, {});
+    const key = requireArg(positionals[0], 'project', 'soja project link ENROLL [path]');
+    const target = positionals[1];
+    await withSession(async (services, session) => {
+        const project = await services.projects.resolve(session, key);
+        // A bare name that is not a folder here means a subfolder of the parent folders.
+        const path = target === undefined
+            ? process.cwd()
+            : !target.includes('/') && !existsSync(target)
+                ? services.folders.findChild(target).path
+                : target;
+        const linked = await services.projects.linkRepository(session, project, path);
+        success(`Linked ${bold(linked.name)} to ${tildify(linked.repositoryPath ?? path)}`);
+        if (linked.repositoryUrl)
+            print(dim(`  ${linked.repositoryUrl}`));
+    });
+}
+async function unlink(args) {
+    const { positionals } = parseCommand(args, {});
+    const key = requireArg(positionals[0], 'project', 'soja project unlink ENROLL');
+    await withSession(async (services, session) => {
+        const project = await services.projects.unlinkRepository(session, await services.projects.resolve(session, key));
+        success(`${bold(project.name)} is no longer linked to a repository`);
+    });
+}
+/** `soja project edit <key> [--name] [--description] [--url]`: an empty value clears description or URL. */
+async function edit(args) {
+    const { values, positionals } = parseCommand(args, {
+        name: { type: 'string' },
+        description: { type: 'string', short: 'd' },
+        url: { type: 'string' },
+    });
+    const key = requireArg(positionals[0], 'project', 'soja project edit ENROLL --name "…" --description "…" --url "…"');
+    if (values.name === undefined && values.description === undefined && values.url === undefined) {
+        throw new ValidationError('Nothing to change.', { hint: 'Pass --name, --description or --url.' });
+    }
+    await withSession(async (services, session) => {
+        const project = await services.projects.update(session, await services.projects.resolve(session, key), {
+            ...(values.name !== undefined ? { name: values.name } : {}),
+            ...(values.description !== undefined ? { description: values.description } : {}),
+            ...(values.url !== undefined ? { repositoryUrl: values.url } : {}),
+        });
+        success(`${bold(project.key)} ${project.name}${project.description ? dim(`  ${project.description}`) : ''}`);
+    });
+}

package/dist/cli/commands/start.js

@@ -0,0 +1,34 @@
+import { statusStyles, symbols } from '../../ui/theme/theme.js';
+import { bold, color, dim, print, success, token } from '../output.js';
+import { withSession } from '../runtime.js';
+import { tildify } from '../../utils/text.js';
+import { parseCommand, requireArg } from './args.js';
+/** `soja start <id>`: the Git flow on top of `soja task start`. */
+export async function startCommand(args) {
+    const { values, positionals } = parseCommand(args, {
+        from: { type: 'string', short: 'f' },
+        link: { type: 'boolean', short: 'l' },
+    });
+    const ref = requireArg(positionals[0], 'task ID', 'soja start SOJA-12 [--from main] [--link]');
+    await withSession(async (services, session) => {
+        const result = await services.git.start(session, ref, {
+            cwd: process.cwd(),
+            from: values.from,
+            link: values.link ?? false,
+        });
+        const status = statusStyles[result.task.status];
+        success(`${bold(result.task.ref)} ${symbols.arrow} ${token(status, status.label)}  ${dim(result.task.title)}`);
+        const where = dim(`in ${tildify(result.root)}`);
+        const lines = {
+            created: `created ${color('green', result.branch)}${result.base ? dim(` from ${result.base}`) : ''} ${where}`,
+            recreated: `recreated ${color('green', result.branch)}${result.base ? dim(` from ${result.base}`) : ''} ${where}`,
+            switched: `switched to ${color('green', result.branch)} ${where}`,
+            current: `already on ${color('green', result.branch)} ${where}`,
+        };
+        print(`  ${lines[result.action]}`);
+        if (result.carried > 0)
+            print(dim(`  ${result.carried} uncommitted change${result.carried === 1 ? '' : 's'} came along`));
+        if (result.linked)
+            print(dim(`  linked ${result.task.project?.name ?? 'the project'} to this repository`));
+    });
+}

package/dist/cli/commands/sync.js

@@ -0,0 +1,43 @@
+import { ValidationError } from '../../domain/errors.js';
+import { formatRelative } from '../../utils/time.js';
+import { bold, color, dim, print, success } from '../output.js';
+import { withServices } from '../runtime.js';
+import { parseCommand } from './args.js';
+/** `soja sync [--dismiss]`: sync now, then show what needs attention (remote mode). */
+export async function syncCommand(args) {
+    const { values } = parseCommand(args, { dismiss: { type: 'boolean' } });
+    await withServices(async (services) => {
+        const sync = services.sync;
+        if (!sync)
+            throw new ValidationError('SOJA is in local mode; there is nothing to sync.', { hint: '`soja login --server <url>` to work with a team.' });
+        const session = await services.session.current();
+        if (!session)
+            return;
+        const workspaceId = session.workspace.id;
+        const report = await sync.syncNow(workspaceId);
+        const status = await sync.status(workspaceId);
+        if (!report.online)
+            print(color('yellow', `Offline. ${status.pending} change${status.pending === 1 ? '' : 's'} queued; they are sent when you reconnect.`));
+        else if (report.error)
+            print(color('yellow', `Synced partially: ${report.error}`));
+        else
+            success(`Synced ${bold(session.workspace.name)} ${dim(`· sent ${report.pushed}, received ${report.pulledTasks} task update${report.pulledTasks === 1 ? '' : 's'}${report.pulledMessages ? ` and ${report.pulledMessages} message${report.pulledMessages === 1 ? '' : 's'}` : ''}`)}`);
+        if (status.lastSyncAt)
+            print(dim(`  last sync ${formatRelative(status.lastSyncAt)}`));
+        const notices = await sync.notices(workspaceId);
+        if (notices.length === 0)
+            return;
+        print();
+        print(bold('Needs your attention'));
+        for (const notice of notices) {
+            print(`  ${notice.kind === 'conflict' ? color('yellow', '!') : color('red', '✕')} ${notice.message}`);
+            if (notice.kind === 'conflict' && notice.field) {
+                print(dim(`    restore it: soja task show ${notice.taskRef}, then edit ${notice.field}; or dismiss with \`soja sync --dismiss\``));
+            }
+            if (values.dismiss)
+                await sync.dismissNotice(notice.id);
+        }
+        if (values.dismiss)
+            print(dim('  Dismissed.'));
+    });
+}

package/dist/cli/commands/task.js

@@ -0,0 +1,309 @@
+import { createInterface } from 'node:readline/promises';
+import { FILTER_LABELS } from '../../application/filters.js';
+import { ValidationError } from '../../domain/errors.js';
+import { activeCount, countStatuses, TASK_PRIORITIES, TASK_STATUSES, TASK_TYPES, TYPE_LABELS } from '../../domain/task.js';
+import { priorityStyles, statusStyles, symbols } from '../../ui/theme/theme.js';
+import { clampLines, wrapText } from '../../utils/text.js';
+import { formatRelative, formatStamp } from '../../utils/time.js';
+import { tildify } from '../../utils/text.js';
+import { bold, color, dim, print, success, taskLine, token } from '../output.js';
+import { editInEditor } from '../../utils/editor.js';
+import { confirmTyped } from '../prompt.js';
+import { withSession } from '../runtime.js';
+import { oneOf, parseCommand, requireArg } from './args.js';
+export async function taskCommand(args) {
+    const [sub, ...rest] = args;
+    switch (sub) {
+        case undefined:
+        case 'list':
+        case 'ls':
+            return list(rest);
+        case 'create':
+        case 'new':
+        case 'add':
+            return create(rest);
+        case 'show':
+        case 'view':
+            return show(rest);
+        case 'done':
+        case 'start':
+        case 'reopen':
+            return transition(sub, rest);
+        case 'archive':
+        case 'restore':
+            return archive(sub, rest);
+        case 'delete':
+            return remove(rest);
+        case 'comment':
+            return comment(rest);
+        case 'describe':
+            return describe(rest);
+        default:
+            throw new ValidationError(`Unknown task command “${sub}”.`, { hint: 'Try: list, create, show, start, done, reopen, comment, describe, archive, restore, delete.' });
+    }
+}
+async function list(args) {
+    const { values } = parseCommand(args, {
+        all: { type: 'boolean', short: 'A' },
+        status: { type: 'string', short: 's' },
+        project: { type: 'string', short: 'p' },
+        archived: { type: 'boolean' },
+    });
+    const status = oneOf(values.status, ['todo', 'in_progress', 'review', 'blocked', 'done'], 'status');
+    const filter = values.archived ? 'archived' : (status ?? (values.all ? 'all' : 'mine'));
+    await withSession(async (services, session) => {
+        await reportMerges(services, session);
+        const project = values.project ? await services.projects.resolve(session, values.project) : null;
+        const tasks = await services.tasks.list(session, filter, project ? { projectId: project.id } : {});
+        const heading = filter === 'mine' ? 'MY WORK' : FILTER_LABELS[filter].toUpperCase();
+        print(`${bold(heading)}  ${dim([session.workspace.name, project?.name].filter(Boolean).join(' / '))}`);
+        print();
+        if (tasks.length === 0) {
+            print(dim(filter === 'mine' ? "  No tasks assigned. You're free." : '  Nothing here.'));
+            return;
+        }
+        for (const task of tasks)
+            print(taskLine(task, { showAssignee: filter !== 'mine' }));
+        print();
+        const counts = countStatuses(tasks);
+        print(dim(filter === 'done' || filter === 'archived'
+            ? `${tasks.length} ${filter}`
+            : `${activeCount(counts)} active ${symbols.dot} ${counts.in_progress} in progress ${symbols.dot} ${counts.review} review ${symbols.dot} ${counts.blocked} blocked`));
+    });
+}
+async function create(args) {
+    const { values, positionals } = parseCommand(args, {
+        project: { type: 'string', short: 'p' },
+        type: { type: 'string', short: 't' },
+        priority: { type: 'string', short: 'P' },
+        status: { type: 'string', short: 's' },
+        assignee: { type: 'string', short: 'a' },
+        requester: { type: 'string', short: 'r' },
+        description: { type: 'string', short: 'd' },
+    });
+    const type = oneOf(values.type, TASK_TYPES, 'type');
+    const priority = oneOf(values.priority, TASK_PRIORITIES, 'priority');
+    const status = oneOf(values.status, TASK_STATUSES, 'status');
+    const title = positionals.join(' ').trim() || (await askTitle());
+    await withSession(async (services, session) => {
+        // Inside a linked repository, its project is the default.
+        const project = values.project
+            ? await services.projects.resolve(session, values.project)
+            : await services.projects.findByRepository(session, process.cwd());
+        const projectId = project?.id ?? null;
+        const assigneeId = await resolveAssignee(services, session, values.assignee);
+        const created = await services.tasks.create(session, {
+            title,
+            projectId,
+            ...(type ? { type } : {}),
+            ...(priority ? { priority } : {}),
+            ...(status ? { status } : {}),
+            ...(assigneeId !== undefined ? { assigneeId } : {}),
+            requester: values.requester ?? null,
+            description: values.description ?? null,
+        });
+        // Remote mode: send it now so the real number shows when online (offline it stays SOJA-?n).
+        if (services.sync)
+            await services.sync.syncNow(session.workspace.id);
+        const task = services.sync ? await services.tasks.get(session, created) : created;
+        success(`Created ${bold(task.ref)}  ${task.title}`);
+        const details = [
+            task.project?.name,
+            token(priorityStyles[task.priority]),
+            task.assignee ? `@${task.assignee.username}` : 'unassigned',
+            task.requester ? `for ${task.requester}` : undefined,
+        ];
+        print(dim(`  ${details.filter(Boolean).join(`  ${symbols.dot}  `)}`));
+    });
+}
+async function resolveAssignee(services, session, value) {
+    if (value === undefined)
+        return undefined;
+    if (['none', 'nobody', '-'].includes(value.toLowerCase()))
+        return null;
+    if (['me', '@me'].includes(value.toLowerCase()))
+        return session.user.id;
+    return (await services.workspaces.findMember(session, value)).id;
+}
+async function askTitle() {
+    if (!process.stdin.isTTY) {
+        throw new ValidationError('A task needs a title.', { hint: 'Usage: soja task create "Fix Stripe webhook"' });
+    }
+    const readline = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await readline.question(`${bold('Title')} ${color('green', '›')} `)).trim();
+    }
+    finally {
+        readline.close();
+    }
+}
+async function show(args) {
+    const { positionals } = parseCommand(args, {});
+    const ref = requireArg(positionals[0], 'task ID', 'soja task show SOJA-12');
+    await withSession(async (services, session) => {
+        await reportMerges(services, session, ref);
+        const task = await services.tasks.get(session, ref);
+        printDetails(task);
+        printGit(task.ref, await services.git.inspect(session, task, process.cwd()));
+        if (task.branch) {
+            const pr = await services.git.pullRequest(session, task, process.cwd());
+            if (pr.status === 'found') {
+                print(`  PR ${bold(`#${pr.pr.number}`)} ${pr.pr.state}  ${dim(pr.pr.url)}  ${dim(`details: soja pr status ${task.ref}`)}`);
+            }
+            else if (pr.status === 'unavailable')
+                print(dim(`  PR: ${pr.reason}`));
+        }
+    });
+}
+function printDetails(task) {
+    const width = Math.min(process.stdout.columns || 80, 100) - 2;
+    const status = statusStyles[task.status];
+    print(`${color('green', bold(task.ref))}  ${dim(TYPE_LABELS[task.type])}`);
+    print(bold(task.title));
+    print(`${token(status, `${status.glyph} ${status.label}`)}   ${token(priorityStyles[task.priority])}`);
+    print();
+    const field = (label, value, hint) => print(`${dim(label.padEnd(14))}${value ?? dim('—')}${hint ? dim(`  ${hint}`) : ''}`);
+    field('Project', task.project?.name);
+    field('Assignee', task.assignee ? `@${task.assignee.username}` : null, task.assignee?.displayName);
+    field('Requested by', task.requester);
+    field('Branch', task.branch, task.branch ? undefined : `suggested ${task.suggestedBranch}`);
+    field('Created', formatStamp(task.createdAt), task.creator ? `by @${task.creator.username}` : undefined);
+    print();
+    if (task.description)
+        for (const line of wrapText(task.description, width - 2))
+            print(`  ${line}`);
+    else
+        print(dim('  No description.'));
+    print();
+    print(dim(bold('ACTIVITY')));
+    const actorWidth = Math.min(18, Math.max(8, ...task.timeline.map((entry) => (entry.actor?.username.length ?? 0) + 1)) + 2);
+    for (const entry of task.timeline) {
+        const prefix = `${dim(formatStamp(entry.at).padEnd(7))}${(entry.actor ? `@${entry.actor.username}` : '').padEnd(actorWidth)}`;
+        if (entry.kind === 'event')
+            print(`${prefix}${dim(entry.text)}`);
+        else {
+            const [first, ...more] = clampLines(wrapText(entry.body, Math.max(20, width - 9 - actorWidth)), 6);
+            print(`${prefix}${color('green', symbols.comment)} ${first ?? ''}`);
+            for (const line of more)
+                print(`${' '.repeat(7 + actorWidth + 2)}${line}`);
+        }
+    }
+}
+/** Closes tasks whose branch was merged outside SOJA and says so before the output. */
+async function reportMerges(services, session, only) {
+    const results = await services.git.detectMerges(session, process.cwd(), only ? { only } : {}).catch(() => []);
+    for (const result of results) {
+        if (result.kind === 'merged')
+            success(`${bold(result.task.ref)} was merged into ${result.into} outside SOJA ${symbols.arrow} Done`);
+        else
+            print(dim(`${result.task.ref}: branch ${result.branch} was deleted with no merge found`));
+    }
+    if (results.length)
+        print();
+}
+function printGit(ref, state) {
+    print();
+    print(dim(bold('GIT')));
+    if (state.status === 'unavailable') {
+        print(dim(`  ${state.reason}${state.hint ? `  ${state.hint}` : ''}`));
+        return;
+    }
+    const where = dim(`in ${tildify(state.root)}`);
+    if (!state.branchExists) {
+        print(`  ${dim(state.recorded ? 'branch deleted, no merge found:' : 'not started:')} ${state.branch} ${where}`);
+        print(dim(`  run \`soja start ${ref}\` to create it${state.recorded ? ', or forget it from the Git menu (g)' : ''}`));
+    }
+    else {
+        const checkout = state.checkedOut
+            ? color('green', `${symbols.active} checked out`)
+            : dim(`not checked out (on ${state.currentBranch ?? 'detached HEAD'})`);
+        print(`  ${state.branch}  ${checkout}  ${where}`);
+    }
+    if (state.uncommitted > 0)
+        print(dim(`  ${state.uncommitted} uncommitted change${state.uncommitted === 1 ? '' : 's'}`));
+    for (const commit of state.commits.slice(0, 5)) {
+        print(`  ${color('yellow', commit.shortHash)} ${commit.subject} ${dim(`${commit.author}, ${formatRelative(commit.date)}`)}`);
+    }
+    if (state.commits.length > 5)
+        print(dim(`  ${symbols.ellipsis} ${state.commits.length - 5} more`));
+}
+/**
+ * Text for a command: the arguments, `-` for stdin, or the editor when
+ * nothing is given in a terminal. Null means the editor was closed without saving.
+ */
+async function textFrom(words, editor) {
+    if (words.length === 1 && words[0] === '-') {
+        const chunks = [];
+        for await (const chunk of process.stdin)
+            chunks.push(chunk);
+        return Buffer.concat(chunks).toString('utf8').replace(/\s+$/, '');
+    }
+    if (words.length > 0)
+        return words.join(' ');
+    if (!process.stdin.isTTY)
+        throw new ValidationError('Nothing to write.', { hint: 'Pass the text, or - to read it from stdin.' });
+    return editInEditor(editor.initial, { name: editor.name });
+}
+/** `soja task comment <id> [text|-]`: without text, opens $EDITOR. */
+async function comment(args) {
+    const { positionals } = parseCommand(args, {});
+    const ref = requireArg(positionals[0], 'task ID', 'soja task comment SOJA-12 "text"  (or - for stdin, or nothing for $EDITOR)');
+    const text = await textFrom(positionals.slice(1), { initial: '', name: `${ref}-comment.md` });
+    if (text === null || !text.trim())
+        return print(dim('Nothing written. No comment added.'));
+    await withSession(async (services, session) => {
+        await services.tasks.comment(session, ref, text);
+        const task = await services.tasks.get(session, ref);
+        success(`Commented on ${bold(task.ref)}`);
+    });
+}
+/** `soja task describe <id> [text|-]`: replaces the description; without text, edits it in $EDITOR. */
+async function describe(args) {
+    const { positionals } = parseCommand(args, {});
+    const ref = requireArg(positionals[0], 'task ID', 'soja task describe SOJA-12 "text"  (or - for stdin, or nothing for $EDITOR)');
+    await withSession(async (services, session) => {
+        const task = await services.tasks.get(session, ref);
+        const text = await textFrom(positionals.slice(1), { initial: task.description ?? '', name: `${task.ref}.md` });
+        if (text === null)
+            return print(dim('The editor closed without saving. Nothing changed.'));
+        if (text === (task.description ?? ''))
+            return print(dim('Description unchanged.'));
+        await services.tasks.update(session, task, { description: text });
+        success(`${bold(task.ref)} description ${text ? 'saved' : 'cleared'}`);
+    });
+}
+async function archive(action, args) {
+    const { positionals } = parseCommand(args, {});
+    const ref = requireArg(positionals[0], 'task ID', `soja task ${action} SOJA-12`);
+    await withSession(async (services, session) => {
+        const task = action === 'archive' ? await services.tasks.archive(session, ref) : await services.tasks.restore(session, ref);
+        success(action === 'archive' ? `${bold(task.ref)} archived ${dim('· soja task list --archived, or soja task restore')}` : `${bold(task.ref)} is back in the lists`);
+    });
+}
+/** `soja task delete <id> [--yes]`: owners only; you type the ID to confirm. */
+async function remove(args) {
+    const { values, positionals } = parseCommand(args, { yes: { type: 'boolean', short: 'y' } });
+    const ref = requireArg(positionals[0], 'task ID', 'soja task delete SOJA-12 [--yes]');
+    await withSession(async (services, session) => {
+        const task = await services.tasks.get(session, ref);
+        print(`${bold(task.ref)} ${task.title}`);
+        print(dim('  Its comments and timeline are deleted too, for the whole team. `soja task archive` keeps it restorable.'));
+        if (!(await confirmTyped('Delete it permanently?', task.ref, values.yes)))
+            return print(dim('Cancelled.'));
+        await services.tasks.remove(session, task);
+        success(`${bold(task.ref)} deleted`);
+    });
+}
+async function transition(action, args) {
+    const { positionals } = parseCommand(args, {});
+    const ref = requireArg(positionals[0], 'task ID', `soja task ${action} SOJA-12`);
+    await withSession(async (services, session) => {
+        const task = action === 'done'
+            ? await services.tasks.complete(session, ref)
+            : action === 'start'
+                ? await services.tasks.start(session, ref)
+                : await services.tasks.reopen(session, ref);
+        const status = statusStyles[task.status];
+        success(`${bold(task.ref)} ${symbols.arrow} ${token(status, status.label)}  ${dim(task.title)}`);
+    });
+}

package/dist/cli/commands/tui.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { SojaError } from '../../domain/errors.js';
+import { bootstrap, createUpdater } from '../../bootstrap.js';
+import { detectThemeMode } from '../../ui/theme/detect.js';
+import { setThemeMode } from '../../ui/theme/theme.js';
+import { App } from '../../ui/App.js';
+import { FileConfigStore } from '../../config/config.js';
+import { CredentialStore } from '../../config/credentials.js';
+import { resolvePaths } from '../../config/paths.js';
+export async function runInterface(options = {}) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new SojaError("SOJA's interface needs an interactive terminal.", {
+            hint: 'For scripts, use the commands in `soja --help`.',
+        });
+    }
+    const paths = resolvePaths();
+    const configStore = new FileConfigStore(paths.configFile);
+    const savedConfig = configStore.load();
+    const hasRemoteToken = savedConfig?.remote ? Boolean(new CredentialStore(paths.credentialsFile).token(savedConfig.remote.apiUrl)) : true;
+    const runtime = await bootstrap({ forceLocal: savedConfig?.mode === 'remote' && !hasRemoteToken });
+    let reopenInCurrentMode = false;
+    // A daily copy of the database in use, kept for a week. Never blocks opening SOJA.
+    try {
+        runtime.services.backups.auto();
+    }
+    catch {
+        // Best effort: `soja backup` reports problems when asked directly.
+    }
+    try {
+        const updates = createUpdater();
+        // Light or dark palette, from the terminal's own background (SOJA_THEME overrides).
+        setThemeMode(await detectThemeMode());
+        const instance = render(_jsx(App, { services: runtime.services, welcomeOnLocal: savedConfig?.mode === 'remote' && !hasRemoteToken, updates: () => updates.cachedCheck(), mouse: process.env.SOJA_MOUSE !== '0', ...(options.route ? { initialRoute: options.route } : {}) }), { alternateScreen: true, exitOnCtrlC: true });
+        await instance.waitUntilExit();
+        reopenInCurrentMode = new FileConfigStore(runtime.paths.configFile).load()?.mode !== runtime.services.environment.mode;
+    }
+    finally {
+        runtime.close();
+    }
+    if (reopenInCurrentMode)
+        await runInterface(options);
+}

package/dist/cli/commands/update.js

@@ -0,0 +1,20 @@
+import { createUpdater } from '../../bootstrap.js';
+import { bold, color, dim, print, success } from '../output.js';
+import { confirm } from '../prompt.js';
+import { parseCommand } from './args.js';
+/** `soja update [--check] [--yes]`: installs the newest release with gh and npm. */
+export async function updateCommand(args) {
+    const { values } = parseCommand(args, { check: { type: 'boolean' }, yes: { type: 'boolean', short: 'y' } });
+    const updater = createUpdater();
+    const found = await updater.check();
+    if (!found.available)
+        return success(`SOJA ${bold(`v${found.current}`)} is the latest version.`);
+    print(`${color('green', `SOJA v${found.latest}`)} is available ${dim(`(you have v${found.current})`)}`);
+    print(dim(`  Package details: npm view soja-cli@${found.latest}`));
+    if (values.check)
+        return;
+    if (!(await confirm('Install it now?', values.yes)))
+        return print(dim('Cancelled.'));
+    await updater.install(found.latest);
+    success(`Installed SOJA v${found.latest}. Your data and settings stay as they are.`);
+}

package/dist/cli/commands/workspace.js

@@ -0,0 +1,55 @@
+import { SojaError, ValidationError } from '../../domain/errors.js';
+import { symbols } from '../../ui/theme/theme.js';
+import { bold, color, dim, print, success } from '../output.js';
+import { withServices, withSession } from '../runtime.js';
+import { parseCommand, requireArg } from './args.js';
+export async function workspaceCommand(args) {
+    const [sub, ...rest] = args;
+    if (sub === undefined || sub === 'list' || sub === 'ls')
+        return list();
+    if (sub === 'use' || sub === 'switch')
+        return switchWorkspace(rest);
+    if (sub === 'create' || sub === 'new')
+        return create(rest);
+    if (sub === 'add' || sub === 'add-member')
+        return addMember(rest);
+    throw new ValidationError(`Unknown workspace command “${sub}”.`, { hint: 'Try: list, create <name>, add <username>, use <workspace>.' });
+}
+async function list() {
+    await withSession(async (services, session) => {
+        for (const workspace of await services.workspaces.list(session.user)) {
+            const current = workspace.id === session.workspace.id;
+            print(`${current ? color('green', symbols.active) : ' '} ${current ? bold(workspace.name) : workspace.name}  ${dim(`${workspace.slug} ${symbols.dot} ${workspace.role}`)}`);
+        }
+    });
+}
+export async function switchWorkspace(args) {
+    const { positionals } = parseCommand(args, {});
+    const target = requireArg(positionals.join(' ').trim(), 'workspace', 'soja use bravos-development');
+    await withSession(async (services, session) => {
+        const next = await services.workspaces.switchTo(session.user, target);
+        success(`Now in ${bold(next.workspace.name)}`);
+    });
+}
+async function create(args) {
+    const { positionals } = parseCommand(args, {});
+    const name = requireArg(positionals.join(' ').trim(), 'workspace name', 'soja workspace create "Bravos Development"');
+    await withServices(async (services) => {
+        // Not `current()`: in remote mode you may have no workspace yet, but you are signed in.
+        const user = await services.session.user();
+        if (!user)
+            throw new SojaError('SOJA is not set up yet.', { hint: 'Run `soja` once, or `soja login --server <url>`.' });
+        const workspace = await services.workspaces.create(user, { name });
+        await services.workspaces.switchTo(user, workspace.id);
+        success(`Created ${bold(workspace.name)} ${dim(workspace.slug)} ${dim('· now active')}`);
+    });
+}
+/** Adds a developer to the active workspace (in remote mode: someone who already ran `soja login`). */
+async function addMember(args) {
+    const { values, positionals } = parseCommand(args, { name: { type: 'string', short: 'n' } });
+    const username = requireArg(positionals[0], 'username', 'soja workspace add angel [--name "Angel"]');
+    await withSession(async (services, session) => {
+        const member = await services.workspaces.addMember(session, { username, ...(values.name ? { displayName: values.name } : {}) });
+        success(`@${member.username} joined ${bold(session.workspace.name)}`);
+    });
+}