soja-cli 1.4.0

package/dist/cli/index.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { ValidationError } from '../domain/errors.js';
+import { toDisplayError } from '../utils/errors.js';
+import { deleteAccountCommand, loginCommand, logoutCommand, modeCommand, whoamiCommand } from './commands/account.js';
+import { accessCommand } from './commands/access.js';
+import { devCommand } from './commands/dev.js';
+import { foldersCommand } from './commands/folders.js';
+import { backupCommand } from './commands/backup.js';
+import { updateCommand } from './commands/update.js';
+import { chatCommand } from './commands/chat.js';
+import { importLocalCommand } from './commands/import.js';
+import { branchCommand, commitCommand, mergeCommand, pullRequestCommand, pushCommand } from './commands/git-ops.js';
+import { printHelp, printVersion } from './commands/info.js';
+import { projectCommand } from './commands/project.js';
+import { taskCommand } from './commands/task.js';
+import { startCommand } from './commands/start.js';
+import { syncCommand } from './commands/sync.js';
+import { runInterface } from './commands/tui.js';
+import { switchWorkspace, workspaceCommand } from './commands/workspace.js';
+import { printError } from './output.js';
+async function main(argv) {
+    const [command, ...rest] = argv;
+    switch (command) {
+        case undefined:
+            return runInterface();
+        case '-h':
+        case '--help':
+        case 'help':
+            return printHelp();
+        case '-v':
+        case '--version':
+        case 'version':
+            return printVersion();
+        case 'task':
+        case 'tasks':
+        case 't':
+            return taskCommand(rest);
+        case 'project':
+        case 'projects':
+            return projectCommand(rest);
+        case 'workspace':
+        case 'workspaces':
+            return workspaceCommand(rest);
+        case 'use':
+            return switchWorkspace(rest);
+        case 'start':
+            return startCommand(rest);
+        case 'folders':
+        case 'folder':
+            return foldersCommand(rest);
+        case 'commit':
+            return commitCommand(rest);
+        case 'merge':
+            return mergeCommand(rest);
+        case 'branch':
+            return branchCommand(rest);
+        case 'push':
+            return pushCommand(rest);
+        case 'pr':
+            return pullRequestCommand(rest);
+        case 'dev':
+            return devCommand(rest);
+        case 'login':
+            return loginCommand(rest);
+        case 'access':
+            return accessCommand(rest);
+        case 'logout':
+            return logoutCommand();
+        case 'account':
+            if (rest[0] === 'delete')
+                return deleteAccountCommand(rest.slice(1));
+            throw new ValidationError('Use `soja account delete [--yes]`.');
+        case 'whoami':
+            return whoamiCommand();
+        case 'mode':
+            return modeCommand(rest);
+        case 'sync':
+            return syncCommand(rest);
+        case 'chat':
+            return chatCommand(rest);
+        case 'import-local':
+            return importLocalCommand(rest);
+        case 'backup':
+        case 'backups':
+            return backupCommand(rest);
+        case 'update':
+        case 'upgrade':
+            return updateCommand(rest);
+        default:
+            throw new ValidationError(`Unknown command “${command}”.`, { hint: 'See `soja --help`.' });
+    }
+}
+// `soja task list | head` closes the pipe early; that is not an error. Stop
+// writing but let the command finish: in remote mode it still has to sync.
+process.stdout.on('error', (error) => {
+    if (error.code !== 'EPIPE')
+        throw error;
+    process.stdout.write = (() => true);
+});
+main(process.argv.slice(2)).catch((error) => {
+    printError(toDisplayError(error));
+    process.exitCode = 1;
+});

package/dist/cli/output.js

@@ -0,0 +1,56 @@
+import { styleText } from 'node:util';
+import { priorityStyles, statusStyles, symbols } from '../ui/theme/theme.js';
+/** Styles text for stdout. Plain automatically when piped or when NO_COLOR is set. */
+export function paint(format, text, stream = process.stdout) {
+    return styleText(format, text, { stream });
+}
+export const bold = (text) => paint('bold', text);
+export const dim = (text) => paint('dim', text);
+export const color = (name, text) => paint(name, text);
+export function token(style, text = style.label) {
+    const formats = [];
+    if (style.color)
+        formats.push(style.color);
+    if (style.bold)
+        formats.push('bold');
+    if (style.dim)
+        formats.push('dim');
+    return formats.length ? paint(formats, text) : text;
+}
+export function print(line = '') {
+    process.stdout.write(`${line}\n`);
+}
+export function success(message) {
+    print(`${color('green', symbols.check)} ${message}`);
+}
+export function printError(error) {
+    const stream = process.stderr;
+    stream.write(`${paint('red', `${symbols.cross} ${error.message}`, stream)}\n`);
+    if (error.hint)
+        stream.write(`${paint('dim', `  ${error.hint}`, stream)}\n`);
+    if (error.debug)
+        stream.write(`\n${paint('dim', error.debug, stream)}\n`);
+}
+const pad = (text, width) => (text.length >= width ? `${text.slice(0, width - 1)}${symbols.ellipsis}` : text.padEnd(width));
+/** One aligned line per task. Narrow terminals drop project and status labels. */
+export function taskLine(task, options = {}, columns = process.stdout.columns || 100) {
+    const priority = priorityStyles[task.priority];
+    const status = statusStyles[task.status];
+    const parts = [dim(pad(task.ref, 10)), token(priority, pad(priority.label, 8))];
+    let used = 18;
+    if (columns >= 80) {
+        parts.push(pad(task.project?.name ?? '—', 15), token(status, pad(`${status.glyph} ${status.label}`, 15)));
+        used += 30;
+    }
+    else {
+        parts.push(token(status, `${status.glyph} `));
+        used += 2;
+    }
+    if (columns >= 100 && options.showAssignee !== false) {
+        parts.push(dim(pad(task.assignee ? `@${task.assignee.username}` : '—', 11)));
+        used += 11;
+    }
+    const room = Math.max(12, columns - used - 2);
+    parts.push(task.title.length > room ? `${task.title.slice(0, room - 1)}${symbols.ellipsis}` : task.title);
+    return `  ${parts.join('')}`;
+}

package/dist/cli/prompt.js

@@ -0,0 +1,28 @@
+import { createInterface } from 'node:readline/promises';
+import { ValidationError } from '../domain/errors.js';
+import { dim } from './output.js';
+/** Yes/no on the terminal; `--yes` skips it, and without a terminal it refuses. */
+export async function confirm(question, yes) {
+    if (yes)
+        return true;
+    const answer = await ask(`${question} ${dim('[y/N]')} `);
+    return /^y(es)?$/i.test(answer.trim());
+}
+/** For what cannot be undone: the answer must be exactly `expected`. */
+export async function confirmTyped(question, expected, yes) {
+    if (yes)
+        return true;
+    const answer = await ask(`${question} ${dim(`Type ${expected} to confirm:`)} `);
+    return answer.trim().toUpperCase() === expected.toUpperCase();
+}
+async function ask(prompt) {
+    if (!process.stdin.isTTY)
+        throw new ValidationError('Refusing to continue without confirmation.', { hint: 'Pass --yes.' });
+    const readline = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await readline.question(prompt);
+    }
+    finally {
+        readline.close();
+    }
+}

package/dist/cli/runtime.js

@@ -0,0 +1,43 @@
+import { bootstrap } from '../bootstrap.js';
+import { SojaError } from '../domain/errors.js';
+import { paint } from './output.js';
+/** Opens the local database for one command and always closes it. */
+export async function withServices(work) {
+    const runtime = await bootstrap();
+    try {
+        return await work(runtime.services);
+    }
+    finally {
+        runtime.close();
+    }
+}
+export async function withSession(work) {
+    return withServices(async (services) => {
+        const session = await services.session.current();
+        if (!session) {
+            throw new SojaError('SOJA is not set up yet.', { hint: 'Run `soja` once to create your user and workspace.' });
+        }
+        // Remote mode: pull before (fresh data) and push after (your changes). Offline still works.
+        const sync = services.sync;
+        if (sync)
+            await sync.syncNow(session.workspace.id);
+        const result = await work(services, session);
+        if (sync) {
+            const report = await sync.syncNow(session.workspace.id);
+            const status = await sync.status(session.workspace.id);
+            if (!report.online)
+                printStatus(`offline · ${plural(status.pending, 'change')} queued, sent when you reconnect`);
+            else if (status.pending > 0)
+                printStatus(`${plural(status.pending, 'change')} not synced yet: ${report.error ?? 'will retry'}`);
+            if (report.conflicts || report.rejected || report.chatRejected)
+                printStatus('some changes need your attention: run `soja sync`');
+        }
+        return result;
+    });
+}
+function printStatus(text) {
+    process.stderr.write(`${paint('dim', `⇅ ${text}`, process.stderr)}\n`);
+}
+function plural(count, noun) {
+    return `${count} ${noun}${count === 1 ? '' : 's'}`;
+}

package/dist/config/config.js

@@ -0,0 +1,103 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { z } from 'zod';
+import { ConfigError } from '../domain/errors.js';
+const remoteSchema = z.object({
+    /** SOJA server, e.g. https://api.soja.dev (the token lives in credentials.json). */
+    apiUrl: z.string().url(),
+    /** Signed-in user on that server, so SOJA can open offline from the replica. */
+    userId: z.string().min(1).optional(),
+    /** Active workspace on the server. */
+    workspaceId: z.string().min(1).optional(),
+    /** Imports of local data already done from this machine (`soja import-local`), to warn before repeating. */
+    imports: z.array(z.string()).optional(),
+});
+/**
+ * Both modes live side by side so switching never loses the other one:
+ * `local` uses userId/workspaceId against SQLite; `remote` uses the
+ * `remote` block against a SOJA server.
+ */
+export const configSchema = z
+    .object({
+    mode: z.enum(['local', 'remote']).default('local'),
+    userId: z.string().min(1).optional(),
+    workspaceId: z.string().min(1).optional(),
+    /**
+     * Machine-specific folders that contain project repositories (e.g.
+     * ~/workspace/products, ~/workspace/services). Their subfolders feed the
+     * repository picker.
+     */
+    parentFolders: z.array(z.string().min(1)).default([]),
+    remote: remoteSchema.optional(),
+})
+    .refine((config) => config.mode !== 'remote' || config.remote !== undefined, {
+    error: 'Remote mode needs a server.',
+    path: ['remote'],
+});
+export class FileConfigStore {
+    file;
+    constructor(file) {
+        this.file = file;
+    }
+    load() {
+        let raw;
+        try {
+            raw = readFileSync(this.file, 'utf8');
+        }
+        catch (error) {
+            if (isErrnoException(error) && error.code === 'ENOENT')
+                return null;
+            throw new ConfigError(`Could not read ${this.file}.`, { cause: error });
+        }
+        let json;
+        try {
+            json = JSON.parse(raw);
+        }
+        catch (error) {
+            throw new ConfigError(`${this.file} is not valid JSON.`, {
+                hint: 'Fix the file or delete it to run setup again.',
+                cause: error,
+            });
+        }
+        const parsed = configSchema.safeParse(json);
+        if (!parsed.success) {
+            const mode = typeof json === 'object' && json !== null && 'mode' in json ? json.mode : undefined;
+            if (mode === 'remote') {
+                throw new ConfigError('Remote mode is set but no server is configured.', {
+                    hint: 'Run `soja login --server <url>`, or `soja mode local`.',
+                });
+            }
+            throw new ConfigError(`${this.file} has an unexpected shape.`, {
+                hint: 'Delete it to run setup again.',
+                cause: parsed.error,
+            });
+        }
+        return parsed.data;
+    }
+    save(config) {
+        try {
+            mkdirSync(dirname(this.file), { recursive: true });
+            const temp = `${this.file}.${process.pid}.tmp`;
+            writeFileSync(temp, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+            renameSync(temp, this.file);
+        }
+        catch (error) {
+            throw new ConfigError(`Could not write ${this.file}.`, { cause: error });
+        }
+    }
+}
+export class MemoryConfigStore {
+    config;
+    constructor(config = null) {
+        this.config = config;
+    }
+    load() {
+        return this.config;
+    }
+    save(config) {
+        this.config = config;
+    }
+}
+function isErrnoException(error) {
+    return error instanceof Error && 'code' in error;
+}

package/dist/config/credentials.js

@@ -0,0 +1,68 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { z } from 'zod';
+import { ConfigError } from '../domain/errors.js';
+const credentialsSchema = z.object({
+    /** Server URL → session token. */
+    servers: z.record(z.string(), z.object({ token: z.string().min(1), username: z.string() })).default({}),
+});
+/**
+ * Session tokens for SOJA servers, kept apart from config.json and readable
+ * only by you (mode 0600). SOJA never stores Git or GitHub credentials.
+ */
+export class CredentialStore {
+    file;
+    constructor(file) {
+        this.file = file;
+    }
+    token(apiUrl) {
+        return this.read().servers[normalize(apiUrl)]?.token ?? null;
+    }
+    save(apiUrl, token, username) {
+        const credentials = this.read();
+        credentials.servers[normalize(apiUrl)] = { token, username };
+        this.write(credentials);
+    }
+    remove(apiUrl) {
+        const credentials = this.read();
+        const key = normalize(apiUrl);
+        this.write({ servers: Object.fromEntries(Object.entries(credentials.servers).filter(([server]) => server !== key)) });
+    }
+    read() {
+        let raw;
+        try {
+            raw = readFileSync(this.file, 'utf8');
+        }
+        catch {
+            return { servers: {} };
+        }
+        const parsed = credentialsSchema.safeParse(JSON.parse(raw));
+        if (!parsed.success)
+            throw new ConfigError(`${this.file} has an unexpected shape.`, { hint: 'Delete it and run `soja login` again.' });
+        return parsed.data;
+    }
+    write(credentials) {
+        try {
+            mkdirSync(dirname(this.file), { recursive: true });
+            const temp = `${this.file}.${process.pid}.tmp`;
+            writeFileSync(temp, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 0o600 });
+            chmodSync(temp, 0o600);
+            renameSync(temp, this.file);
+        }
+        catch (error) {
+            throw new ConfigError(`Could not write ${this.file}.`, { cause: error });
+        }
+    }
+}
+/**
+ * The server's base URL. Accepts what people paste after testing it with curl,
+ * e.g. `https://host/v1/health` or `https://host/`, and returns `https://host`.
+ */
+export function normalize(apiUrl) {
+    const trimmed = apiUrl.trim();
+    if (!/^https?:\/\//i.test(trimmed))
+        return trimmed.replace(/\/+$/, '');
+    const url = new URL(trimmed);
+    const base = url.pathname.replace(/\/v1(\/.*)?$/, '').replace(/\/+$/, '');
+    return `${url.protocol}//${url.host}${base}`;
+}

package/dist/config/paths.js

@@ -0,0 +1,18 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** XDG base directories, with the spec's fallbacks when the variables are unset or relative. */
+export function resolvePaths(env = process.env, home = homedir()) {
+    const xdg = (name, fallback) => {
+        const value = env[name];
+        return value && value.startsWith('/') ? value : join(home, fallback);
+    };
+    const dataDir = join(xdg('XDG_DATA_HOME', '.local/share'), 'soja');
+    const configDir = join(xdg('XDG_CONFIG_HOME', '.config'), 'soja');
+    return {
+        dataDir,
+        configDir,
+        databaseFile: join(dataDir, 'soja.db'),
+        configFile: join(configDir, 'config.json'),
+        credentialsFile: join(configDir, 'credentials.json'),
+    };
+}

package/dist/config/server.js

@@ -0,0 +1,21 @@
+/** Public production SOJA API. This is configuration, not a secret. */
+export const DEFAULT_SERVER_URL = 'https://soja-backend-production.up.railway.app';
+/** Do not let a configured public server receive SOJA bearer credentials over cleartext HTTP. */
+export function isSecureServerUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.username || url.password)
+            return false;
+        if (url.protocol === 'https:')
+            return true;
+        if (url.protocol !== 'http:')
+            return false;
+        const hostname = url.hostname.replace(/^\[|\]$/g, '').toLowerCase();
+        const octets = hostname.split('.');
+        const loopbackIpv4 = octets.length === 4 && octets[0] === '127' && octets.every((octet) => /^\d{1,3}$/.test(octet) && Number(octet) <= 255);
+        return hostname === 'localhost' || hostname.endsWith('.localhost') || hostname === '::1' || loopbackIpv4;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/config/version.js

@@ -0,0 +1,7 @@
+import { readFileSync } from 'node:fs';
+import { z } from 'zod';
+// package.json sits two levels above both src/config and dist/config.
+const packageJson = z
+    .object({ version: z.string() })
+    .parse(JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')));
+export const APP_VERSION = packageJson.version;

package/dist/data/local/activity.js

@@ -0,0 +1,33 @@
+import { randomUUID } from 'node:crypto';
+import { asc, eq, sql } from 'drizzle-orm';
+import { taskActivity } from '../../database/schema.js';
+export class LocalActivityRepository {
+    db;
+    clock;
+    constructor(db, clock) {
+        this.db = db;
+        this.clock = clock;
+    }
+    async record(taskId, userId, event) {
+        const [row] = await this.db
+            .insert(taskActivity)
+            .values({ id: randomUUID(), taskId, userId, type: event.type, metadata: event.metadata, createdAt: this.clock() })
+            .returning();
+        if (!row)
+            throw new Error('Expected the database to return a row');
+        return toActivity(row);
+    }
+    async listByTask(taskId) {
+        const rows = await this.db
+            .select()
+            .from(taskActivity)
+            .where(eq(taskActivity.taskId, taskId))
+            .orderBy(asc(taskActivity.createdAt), asc(sql `rowid`));
+        return rows.map(toActivity);
+    }
+}
+// `type` and `metadata` are written together from an ActivityEvent, so the
+// row pair is always one of the union members; TypeScript cannot see that.
+function toActivity(row) {
+    return row;
+}

package/dist/data/local/clock.js

@@ -0,0 +1 @@
+export const systemClock = () => new Date();

package/dist/data/local/comments.js

@@ -0,0 +1,27 @@
+import { randomUUID } from 'node:crypto';
+import { asc, eq, sql } from 'drizzle-orm';
+import { taskComments } from '../../database/schema.js';
+import { must } from './users.js';
+export class LocalCommentRepository {
+    db;
+    clock;
+    constructor(db, clock) {
+        this.db = db;
+        this.clock = clock;
+    }
+    async create(input) {
+        const now = this.clock();
+        const [comment] = await this.db
+            .insert(taskComments)
+            .values({ ...input, id: input.id ?? randomUUID(), createdAt: now, updatedAt: now })
+            .returning();
+        return must(comment);
+    }
+    async listByTask(taskId) {
+        return this.db
+            .select()
+            .from(taskComments)
+            .where(eq(taskComments.taskId, taskId))
+            .orderBy(asc(taskComments.createdAt), asc(sql `rowid`));
+    }
+}

package/dist/data/local/index.js

@@ -0,0 +1,48 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { LocalActivityRepository } from './activity.js';
+import { systemClock } from './clock.js';
+import { LocalCommentRepository } from './comments.js';
+import { LocalProjectRepository } from './projects.js';
+import { LocalTaskRepository } from './tasks.js';
+import { LocalUserRepository } from './users.js';
+import { LocalWorkspaceRepository } from './workspaces.js';
+export function createLocalRepositories(handle, clock = systemClock) {
+    const { db } = handle;
+    return {
+        users: new LocalUserRepository(db, clock),
+        workspaces: new LocalWorkspaceRepository(db, clock),
+        projects: new LocalProjectRepository(db, clock),
+        tasks: new LocalTaskRepository(db, clock),
+        comments: new LocalCommentRepository(db, clock),
+        activity: new LocalActivityRepository(db, clock),
+        transaction: createTransactionRunner(handle),
+    };
+}
+/**
+ * One SQLite connection is shared by every repository, so transactions are
+ * serialized. Nested calls (a service calling another inside a transaction)
+ * join the outer transaction instead of deadlocking on the queue.
+ */
+function createTransactionRunner(handle) {
+    const context = new AsyncLocalStorage();
+    let queue = Promise.resolve();
+    return (work) => {
+        if (context.getStore())
+            return work();
+        const run = async () => {
+            handle.exec('BEGIN IMMEDIATE');
+            try {
+                const result = await context.run(true, work);
+                handle.exec('COMMIT');
+                return result;
+            }
+            catch (error) {
+                handle.exec('ROLLBACK');
+                throw error;
+            }
+        };
+        const result = queue.then(run, run);
+        queue = result.catch(() => undefined);
+        return result;
+    };
+}

package/dist/data/local/projects.js

@@ -0,0 +1,53 @@
+import { randomUUID } from 'node:crypto';
+import { and, asc, eq } from 'drizzle-orm';
+import { projects } from '../../database/schema.js';
+import { NotFoundError } from '../../domain/errors.js';
+import { must } from './users.js';
+export class LocalProjectRepository {
+    db;
+    clock;
+    constructor(db, clock) {
+        this.db = db;
+        this.clock = clock;
+    }
+    async findById(id) {
+        return (await this.db.select().from(projects).where(eq(projects.id, id)).get()) ?? null;
+    }
+    async findByKey(workspaceId, key) {
+        const row = await this.db
+            .select()
+            .from(projects)
+            .where(and(eq(projects.workspaceId, workspaceId), eq(projects.key, key)))
+            .get();
+        return row ?? null;
+    }
+    async listByWorkspace(workspaceId) {
+        return this.db.select().from(projects).where(eq(projects.workspaceId, workspaceId)).orderBy(asc(projects.name));
+    }
+    async create(input) {
+        const now = this.clock();
+        const [project] = await this.db
+            .insert(projects)
+            .values({
+            id: randomUUID(),
+            description: null,
+            repositoryUrl: null,
+            repositoryPath: null,
+            ...input,
+            createdAt: now,
+            updatedAt: now,
+        })
+            .returning();
+        return must(project);
+    }
+    async update(id, patch) {
+        const [project] = await this.db
+            .update(projects)
+            .set({ ...patch, updatedAt: this.clock() })
+            .where(eq(projects.id, id))
+            .returning();
+        if (!project)
+            throw new NotFoundError('That project no longer exists.');
+        return project;
+    }
+}