@mahmoudwael/opai 0.1.0

package/dist/sessions/store.js

@@ -0,0 +1,72 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { configDir } from '../config.js';
+import { ticketKey } from '../providers/types.js';
+export function sessionTickets(registry, provider) {
+    return Object.entries(registry).filter(([key, sessions]) => key.startsWith(`${provider}:`) && sessions.length > 0).map(([key, sessions]) => {
+        const ordered = [...sessions].sort((a, b) => Date.parse(b.lastUsedAt ?? b.createdAt) - Date.parse(a.lastUsedAt ?? a.createdAt));
+        const id = key.slice(provider.length + 1);
+        const snapshot = [...sessions].sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt)).find(session => session.ticket)?.ticket;
+        return { key, id, title: snapshot?.title ?? `Ticket #${id}`, status: snapshot?.status, sessions: ordered, lastUsedAt: ordered[0].lastUsedAt ?? ordered[0].createdAt };
+    }).sort((a, b) => Date.parse(b.lastUsedAt) - Date.parse(a.lastUsedAt));
+}
+export class SessionStore {
+    path;
+    constructor(path = join(configDir, 'sessions.json')) {
+        this.path = path;
+    }
+    async all() {
+        try {
+            const value = JSON.parse(await readFile(this.path, 'utf8'));
+            if (!value || typeof value !== 'object' || Array.isArray(value))
+                throw new Error('Invalid session registry.');
+            return value;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return {};
+            throw error;
+        }
+    }
+    async list(key) { return ((await this.all())[key] ?? []).map(session => ({ ...session, model: session.model ?? null, effort: session.effort ?? null, initialPrompt: session.initialPrompt ?? null })); }
+    async syncTickets(tickets) {
+        const data = await this.all();
+        let updated = 0;
+        for (const ticket of tickets) {
+            for (const session of data[ticketKey(ticket)] ?? []) {
+                if (JSON.stringify(session.ticket) === JSON.stringify(ticket))
+                    continue;
+                session.ticket = ticket;
+                updated++;
+            }
+        }
+        if (updated)
+            await this.save(data);
+        return updated;
+    }
+    async save(data) {
+        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+        const temp = `${this.path}.${randomUUID()}.tmp`;
+        await writeFile(temp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+        await rename(temp, this.path);
+    }
+    async add(key, session) {
+        if (!key.includes(':') || !/^[0-9a-f-]{36}$/i.test(session.sessionId) || !session.cwd || !Number.isFinite(Date.parse(session.createdAt)))
+            throw new Error('Invalid session record.');
+        const data = await this.all();
+        data[key] ??= [];
+        if (!data[key].some(item => item.agent === session.agent && item.sessionId === session.sessionId))
+            data[key].push({ ...session, usedAt: session.usedAt ?? [session.createdAt] });
+        await this.save(data);
+    }
+    async touch(key, sessionId) {
+        const data = await this.all();
+        const session = data[key]?.find(item => item.sessionId === sessionId);
+        if (!session)
+            throw new Error('Session is not registered for this ticket.');
+        session.lastUsedAt = new Date().toISOString();
+        session.usedAt = [...(session.usedAt ?? [session.createdAt]), session.lastUsedAt];
+        await this.save(data);
+    }
+}

package/dist/sessions/sync.js

@@ -0,0 +1,24 @@
+import { ticketKey } from '../providers/types.js';
+export async function syncSessionTickets(store, provider, tickets, includeMissing = false) {
+    let updated = await store.syncTickets(tickets);
+    const unavailable = [];
+    if (!includeMissing)
+        return { updated, unavailable };
+    const listed = new Set(tickets.map(ticketKey));
+    const registry = await store.all();
+    for (const [key, sessions] of Object.entries(registry)) {
+        if (!sessions.length || !key.startsWith(`${provider.identity}:`) || listed.has(key))
+            continue;
+        const id = key.slice(provider.identity.length + 1);
+        try {
+            const ticket = await provider.get(id);
+            if (ticketKey(ticket) !== key)
+                throw new Error('Ticket identity changed.');
+            updated += await store.syncTickets([ticket]);
+        }
+        catch {
+            unavailable.push(id);
+        }
+    }
+    return { updated, unavailable };
+}

package/dist/status.js

@@ -0,0 +1,39 @@
+const faces = ['(˶• ᴗ •˶)⋯', '(˶ᵔ ᴗ ᵔ˶)⌕', '(˶• ⩊ •˶)✧'];
+const spinners = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧'];
+export class StatusBar {
+    output;
+    current = { kind: 'idle', message: 'Ready for your next quest' };
+    constructor(output = process.stdout) {
+        this.output = output;
+    }
+    set(kind, message) { this.current = { kind, message }; }
+    async run(label, work, success) {
+        this.set('loading', label);
+        let frame = 0;
+        const draw = () => {
+            this.output.write(`\r\u001b[2K  ${faces[frame % faces.length]}  ${spinners[frame % spinners.length]} ${label}`);
+            frame++;
+        };
+        if (this.output.isTTY)
+            draw();
+        else
+            this.output.write(`Loading ${label}...\n`);
+        const timer = this.output.isTTY ? setInterval(draw, 120) : undefined;
+        try {
+            const value = await work();
+            this.set('success', success(value));
+            return value;
+        }
+        catch (error) {
+            this.set('error', `${label} failed`);
+            throw error;
+        }
+        finally {
+            if (timer)
+                clearInterval(timer);
+            if (this.output.isTTY)
+                this.output.write('\r\u001b[2K');
+        }
+    }
+}
+export const statusBar = new StatusBar();

package/dist/token.js

@@ -0,0 +1,27 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { configDir } from './config.js';
+export const tokenPath = join(configDir, 'token');
+export async function loadApiToken(path = tokenPath, environment = process.env.OPENPROJECT_API_TOKEN) {
+    if (environment?.trim())
+        return environment.trim();
+    try {
+        const token = (await readFile(path, 'utf8')).trim();
+        return token || undefined;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw new Error(`Could not read OPAI token file at ${path}.`);
+    }
+}
+export async function saveApiToken(token, path = tokenPath) {
+    if (!token.trim())
+        throw new Error('API token cannot be empty.');
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temp = `${path}.${randomUUID()}.tmp`;
+    await writeFile(temp, `${token.trim()}\n`, { mode: 0o600, flag: 'wx' });
+    await chmod(temp, 0o600);
+    await rename(temp, path);
+}

package/dist/ui-state.js

@@ -0,0 +1,33 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { configDir } from './config.js';
+const rotation = ['rabbit', 'chick', 'idle'];
+function nextIndex(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return 0;
+    const index = value.nextMascotIndex;
+    return Number.isInteger(index) && Number(index) >= 0 ? Number(index) % rotation.length : 0;
+}
+export class MascotRotationStore {
+    path;
+    constructor(path = join(configDir, 'ui-state.json')) {
+        this.path = path;
+    }
+    async next() {
+        let index = 0;
+        try {
+            index = nextIndex(JSON.parse(await readFile(this.path, 'utf8')));
+        }
+        catch { /* First launch or invalid state starts with the rabbit. */ }
+        const mascot = rotation[index];
+        try {
+            await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+            const temp = `${this.path}.${randomUUID()}.tmp`;
+            await writeFile(temp, `${JSON.stringify({ nextMascotIndex: (index + 1) % rotation.length }, null, 2)}\n`, { mode: 0o600 });
+            await rename(temp, this.path);
+        }
+        catch { /* Mascot decoration must never prevent OPAI from starting. */ }
+        return mascot;
+    }
+}

package/dist/ui.js

@@ -0,0 +1,204 @@
+import { stripVTControlCharacters } from 'node:util';
+import { statusBar } from './status.js';
+const color = process.stdout.isTTY && !process.env.NO_COLOR;
+const paint = (code, value) => color ? `\u001b[${code}m${value}\u001b[0m` : value;
+export function createOpaiPalette(enabled = color) {
+    const rgb = (red, green, blue) => value => enabled
+        ? `\u001b[38;2;${red};${green};${blue}m${value}\u001b[0m`
+        : value;
+    return {
+        accent: rgb(148, 226, 213),
+        mascot: rgb(245, 194, 231),
+        positive: rgb(166, 227, 161),
+        warning: rgb(249, 226, 175),
+        danger: rgb(243, 139, 168),
+        muted: rgb(88, 91, 112)
+    };
+}
+const opaiPalette = createOpaiPalette();
+export const accent = opaiPalette.accent;
+export const muted = opaiPalette.muted;
+export const bold = (value) => paint(1, value);
+export const warning = opaiPalette.warning;
+export const good = opaiPalette.positive;
+export const danger = opaiPalette.danger;
+const magic = opaiPalette.mascot;
+export function selectionCursor(value = '❯', animated = color) {
+    return animated ? `\u001b[5m${value}\u001b[25m` : value;
+}
+function truncate(value, max) {
+    const chars = [...value];
+    return chars.length > max ? `${chars.slice(0, Math.max(0, max - 1)).join('')}…` : value;
+}
+export function visibleWidth(value) {
+    let width = 0;
+    for (const char of stripVTControlCharacters(value)) {
+        if (/\p{Mark}/u.test(char))
+            continue;
+        const code = char.codePointAt(0);
+        width += code >= 0x1100 && (code <= 0x115f || code === 0x2329 || code === 0x232a ||
+            (code >= 0x2e80 && code <= 0xa4cf) || (code >= 0xac00 && code <= 0xd7a3) ||
+            (code >= 0xf900 && code <= 0xfaff) || (code >= 0xfe10 && code <= 0xfe6f) ||
+            (code >= 0xff00 && code <= 0xff60) || (code >= 0x1f300 && code <= 0x1faff)) ? 2 : 1;
+    }
+    return width;
+}
+function truncateVisible(value, max) {
+    if (max <= 0)
+        return '';
+    if (visibleWidth(value) <= max)
+        return value;
+    let result = '';
+    let width = 0;
+    for (const char of value) {
+        const next = visibleWidth(char);
+        if (width + next > max - 1)
+            break;
+        result += char;
+        width += next;
+    }
+    return `${result}…`;
+}
+function padVisible(value, width) { return value + ' '.repeat(Math.max(0, width - visibleWidth(value))); }
+export function ticketRow(ticket, columns = process.stdout.columns ?? 80) {
+    const rawBadge = ticket.type === 'Bug' ? 'Bug' : ticket.type === 'User Story' ? 'US' : truncate(ticket.typeLabel, 24);
+    const usableWidth = Math.max(20, columns - 4);
+    const typeWidth = 3;
+    const statusWidth = 11;
+    const priorityWidth = 8;
+    const fixedWidth = 8 + 1 + 2 + typeWidth + 1 + statusWidth + 2 + priorityWidth;
+    const titleWidth = Math.max(6, Math.min(58, usableWidth - fixedWidth));
+    const id = truncate(`#${ticket.id}`, 8).padEnd(8);
+    const title = truncate(ticket.title, titleWidth).padEnd(titleWidth);
+    const type = truncate(rawBadge, typeWidth).padEnd(typeWidth);
+    const status = truncate(ticket.status, statusWidth).padEnd(statusWidth);
+    const priority = truncate(ticket.priority?.name ?? '', priorityWidth).padEnd(priorityWidth);
+    const badge = ticket.type === 'Bug' ? danger(type) : ticket.type === 'User Story' ? accent(type) : warning(type);
+    return `${accent(id)} ${title}  ${badge} ${muted(status)}  ${ticket.priority ? bold(priority) : priority}`;
+}
+export function listHighlight(value, columns = process.stdout.columns ?? 80) {
+    const width = Math.max(1, columns - 2);
+    return stripVTControlCharacters(value).split('\n').map(line => {
+        const row = line.padEnd(width);
+        const animatedRow = row.startsWith('❯') ? `${selectionCursor('❯')}${row.slice(1)}` : row;
+        return color ? `\u001b[7m${animatedRow}\u001b[0m` : row;
+    }).join('\n');
+}
+export function sinceLastOpened(value, now = Date.now()) {
+    const elapsed = now - Date.parse(value);
+    if (!Number.isFinite(elapsed) || elapsed < 0)
+        return 'just now';
+    const minutes = Math.floor(elapsed / 60_000);
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `${days}d ago`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `${months}mo ago`;
+    return `${Math.floor(days / 365)}y ago`;
+}
+export function sessionRow(group, columns = process.stdout.columns ?? 80, now = Date.now()) {
+    const agents = [...new Set(group.sessions.map(session => session.agent === 'claude' ? 'Claude' : 'Codex'))].join(' + ');
+    const details = `${agents} · ${group.sessions.length} session${group.sessions.length === 1 ? '' : 's'} · last opened ${sinceLastOpened(group.lastUsedAt, now)}`;
+    const usableWidth = Math.max(20, columns - 4);
+    const statusWidth = 20;
+    const titleWidth = Math.max(8, Math.min(58, usableWidth - 8 - 2 - 2 - statusWidth));
+    const id = truncate(`#${group.id}`, 8).padEnd(8);
+    const title = truncate(group.title, titleWidth).padEnd(titleWidth);
+    const rawStatus = group.status ? `[${truncate(group.status, 18)}]` : '[Status unavailable]';
+    const status = rawStatus.padEnd(statusWidth);
+    const detailIndent = '      ';
+    const visibleDetails = truncateVisible(details, Math.max(1, usableWidth - detailIndent.length));
+    return `${accent(id)}  ${bold(title)}  ${group.status ? accent(status) : muted(status)}\n${detailIndent}${muted(visibleDetails)}`;
+}
+const mascots = {
+    idle: [' /\\_/\\', '(˶ᵔ ᵕ ᵔ˶)✧', ' /|☆|\\'],
+    rabbit: ['  /) /)', '(˶ᵔ ᵕ ᵔ˶)', ' /づ♡づ'],
+    chick: ['   ,_,', ' (˶•ө•˶)', '  /づ✦づ'],
+    claude: [' /\\_/\\', '(˶ᵔ ᴗ ᵔ˶)✦', ' /|⌁|\\'],
+    codex: [' /\\_/\\', '(˶• ⩊ •˶)⚙', ' /|#|\\'],
+    resume: [' /\\_/\\', '(˶ᵔ ᴗ ᵔ˶)↻', ' /|☆|\\'],
+    loading: [' /\\_/\\', '(˶• ᴗ •˶)⋯', ' /|…|\\'],
+    success: [' /\\_/\\', '(˶ᵔ ᴗ ᵔ˶)☆', ' /|☆|\\'],
+    error: [' /\\_/\\', '(˶• ᴗ •˶)♡', ' /|!|\\']
+};
+const mascotWidth = Math.max(...Object.values(mascots).flat().map(visibleWidth));
+let idleMascotMood = 'idle';
+export function setIdleMascotMood(mood) {
+    idleMascotMood = mood;
+}
+function headerParts(title, subtitle, status, columns, mood) {
+    const art = mascots[mood];
+    const symbol = status.kind === 'success' ? '✓' : status.kind === 'error' ? '!' : status.kind === 'loading' ? '◌' : status.kind === 'cached' ? '◆' : '◇';
+    const content = [`OPAI › ${title}`, subtitle ?? '', `${symbol} ${status.message}`];
+    const contentStart = 2 + mascotWidth + 3;
+    if (columns < contentStart + 8) {
+        return { art: art.map(line => `  ${line}`), content: content.map(line => `  ${truncateVisible(line, Math.max(1, columns - 2))}`), stacked: true };
+    }
+    const available = Math.max(1, columns - contentStart);
+    return { art: art.map(line => `  ${padVisible(line, mascotWidth)}   `), content: content.map(line => truncateVisible(line, available)), stacked: false };
+}
+export function renderHeader(title, subtitle, status, columns = 80, mood = idleMascotMood) {
+    const parts = headerParts(title, subtitle, status, columns, mood);
+    return parts.stacked
+        ? [...parts.art, ...parts.content].join('\n')
+        : parts.art.map((art, index) => `${art}${parts.content[index]}`).join('\n');
+}
+function centeredLine(value, columns, style = text => text) {
+    const fitted = truncateVisible(value, Math.max(1, columns));
+    const left = Math.max(0, Math.floor((columns - visibleWidth(fitted)) / 2));
+    return `${' '.repeat(left)}${style(fitted)}`;
+}
+export function renderAgentClosed(detail, mood = 'success', columns = 80) {
+    return [
+        ...mascots[mood].map(line => centeredLine(line, columns, magic)),
+        '',
+        centeredLine('Session closed', columns, value => bold(accent(value))),
+        centeredLine(detail, columns, mood === 'error' ? warning : muted)
+    ].join('\n');
+}
+export function centeredMenuChoices(labels, columns = process.stdout.columns ?? 80) {
+    const width = Math.max(0, ...labels.map(visibleWidth));
+    const left = Math.max(0, Math.floor((columns - width - 2) / 2));
+    return labels.map(label => `${' '.repeat(left)}${label}`);
+}
+export function agentClosedScreen(detail, mood = 'success') {
+    if (process.stdout.isTTY)
+        process.stdout.write('\u001b[2J\u001b[H');
+    console.log(`\n${renderAgentClosed(detail, mood, process.stdout.columns ?? 80)}\n`);
+}
+export function screen(title, subtitle, mood) {
+    if (process.stdout.isTTY)
+        process.stdout.write('\u001b[2J\u001b[H');
+    const { kind, message } = statusBar.current;
+    const selectedMood = mood ?? (kind === 'loading' ? 'loading' : kind === 'success' ? 'success' : kind === 'error' ? 'error' : idleMascotMood);
+    const parts = headerParts(title, subtitle, { kind, message }, process.stdout.columns ?? 80, selectedMood);
+    const styleContent = (value, index) => index === 0 ? bold(accent(value)) : index === 1 ? muted(value) : kind === 'success' ? good(value) : kind === 'error' ? warning(value) : kind === 'loading' ? accent(value) : muted(value);
+    const styled = parts.stacked
+        ? [...parts.art.map(magic), ...parts.content.map(styleContent)].join('\n')
+        : parts.art.map((art, index) => `${magic(art)}${styleContent(parts.content[index], index)}`).join('\n');
+    console.log(`\n${styled}\n`);
+}
+export function hint() { return muted('↑↓ move · type to filter · Enter select · Esc back · Ctrl+C exit'); }
+export function renderGoodbye(mood = idleMascotMood) {
+    const art = mood === 'rabbit'
+        ? ['  /) /)', '₍ᐢ..ᐢ₎♡', '  /づづ']
+        : [' /\\_/\\', '(˶ᵔ ᵕ ᵔ˶)ﾉ', ' /|☆|\\'];
+    return [
+        `  ${magic(art[0])}`,
+        `  ${magic(art[1])}  ${bold('See you next quest, adventurer!')} ${accent('✦')}`,
+        `  ${magic(art[2])}   ${muted('Your saved sessions will be here when you return.')}`
+    ].join('\n');
+}
+export function goodbye() {
+    if (!process.stdout.isTTY)
+        return;
+    console.log(`\n${renderGoodbye()}\n`);
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@mahmoudwael/opai",
+  "version": "0.1.0",
+  "description": "Browse OpenProject tickets, launch Claude Code or Codex, and resume the exact native agent session.",
+  "type": "module",
+  "bin": {
+    "opai": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "config.example.json"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc --project tsconfig.build.json && chmod +x dist/cli.js",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run clean && tsc && chmod +x dist/cli.js && node dist/opai.test.js",
+    "verify": "npm run typecheck && npm test",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run verify"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "author": {
+    "name": "Mahmoud Wael",
+    "email": "mahmoud.wael.raslan@gmail.com",
+    "url": "https://github.com/MahmoudWael"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MahmoudWael/opai.git"
+  },
+  "homepage": "https://github.com/MahmoudWael/opai#readme",
+  "bugs": {
+    "url": "https://github.com/MahmoudWael/opai/issues"
+  },
+  "keywords": [
+    "openproject",
+    "claude-code",
+    "codex",
+    "tickets",
+    "cli",
+    "developer-tools"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.10.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.3"
+  }
+}