mob-coordinator 0.2.1

package/dist/server/server/session-store.js

@@ -0,0 +1,127 @@
+import fs from 'fs';
+import path from 'path';
+import { getSessionsDir, getScrollbackDir, getGitBranch } from './util/platform.js';
+import { SESSION_MAX_AGE_MS } from '../shared/constants.js';
+function log(...args) {
+    const ts = new Date().toISOString().slice(11, 23);
+    console.log(`[${ts}] [session-store]`, ...args);
+}
+export class SessionStore {
+    save(instance, opts) {
+        const data = {
+            id: instance.id,
+            name: instance.name,
+            cwd: instance.cwd,
+            gitBranch: instance.gitBranch,
+            model: instance.model,
+            permissionMode: instance.permissionMode,
+            claudeSessionId: instance.claudeSessionId,
+            previousInstanceId: instance.previousInstanceId,
+            createdAt: instance.createdAt || Date.now(),
+            stoppedAt: instance.stoppedAt,
+            ticket: instance.ticket,
+            subtask: instance.subtask,
+            autoResume: opts?.autoResume,
+        };
+        const filePath = path.join(getSessionsDir(), `${instance.id}.json`);
+        try {
+            fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+        }
+        catch (err) {
+            log(`Failed to save session ${instance.id}:`, err);
+        }
+    }
+    loadAll() {
+        const dir = getSessionsDir();
+        const cutoff = Date.now() - SESSION_MAX_AGE_MS;
+        const instances = [];
+        let files;
+        try {
+            files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+        }
+        catch {
+            return [];
+        }
+        for (const file of files) {
+            try {
+                const filePath = path.join(dir, file);
+                const raw = fs.readFileSync(filePath, 'utf8');
+                const data = JSON.parse(raw);
+                // Skip expired sessions
+                const lastActive = data.stoppedAt || data.createdAt;
+                if (lastActive < cutoff) {
+                    this.removeFiles(data.id);
+                    continue;
+                }
+                instances.push({
+                    id: data.id,
+                    name: data.name,
+                    managed: true,
+                    cwd: data.cwd,
+                    gitBranch: getGitBranch(data.cwd) || data.gitBranch,
+                    state: 'stopped',
+                    lastUpdated: data.stoppedAt || data.createdAt,
+                    model: data.model,
+                    permissionMode: data.permissionMode,
+                    claudeSessionId: data.claudeSessionId,
+                    previousInstanceId: data.previousInstanceId,
+                    createdAt: data.createdAt,
+                    stoppedAt: data.stoppedAt,
+                    historical: true,
+                    ticket: data.ticket,
+                    subtask: data.subtask,
+                    autoResume: data.autoResume,
+                });
+            }
+            catch (err) {
+                log(`Failed to load session from ${file}:`, err);
+            }
+        }
+        log(`Loaded ${instances.length} previous session(s)`);
+        return instances;
+    }
+    pruneExpired() {
+        const dir = getSessionsDir();
+        const cutoff = Date.now() - SESSION_MAX_AGE_MS;
+        let pruned = 0;
+        let files;
+        try {
+            files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+        }
+        catch {
+            return;
+        }
+        for (const file of files) {
+            try {
+                const filePath = path.join(dir, file);
+                const raw = fs.readFileSync(filePath, 'utf8');
+                const data = JSON.parse(raw);
+                const lastActive = data.stoppedAt || data.createdAt;
+                if (lastActive < cutoff) {
+                    this.removeFiles(data.id);
+                    pruned++;
+                }
+            }
+            catch {
+                // Skip malformed files
+            }
+        }
+        if (pruned > 0)
+            log(`Pruned ${pruned} expired session(s)`);
+    }
+    remove(instanceId) {
+        this.removeFiles(instanceId);
+    }
+    removeFiles(instanceId) {
+        const sessionPath = path.join(getSessionsDir(), `${instanceId}.json`);
+        const scrollbackPath = path.join(getScrollbackDir(), `${instanceId}.log`);
+        try {
+            fs.unlinkSync(sessionPath);
+        }
+        catch { /* ok */ }
+        try {
+            fs.unlinkSync(scrollbackPath);
+        }
+        catch { /* ok */ }
+    }
+}

package/dist/server/server/settings-manager.js

@@ -0,0 +1,87 @@
+import fs from 'fs';
+import path from 'path';
+import { getMobDir } from './util/platform.js';
+import { DEFAULT_SETTINGS, mergeWithDefaults } from '../shared/settings.js';
+import { createLogger } from './util/logger.js';
+const log = createLogger('settings');
+function clamp(val, min, max) {
+    return Math.max(min, Math.min(max, val));
+}
+function validate(settings) {
+    settings.terminal.fontSize = clamp(Math.round(settings.terminal.fontSize), 8, 24);
+    settings.terminal.scrollbackLines = clamp(Math.round(settings.terminal.scrollbackLines), 100, 100_000);
+    settings.general.maxCachedTerminals = clamp(Math.round(settings.general.maxCachedTerminals), 1, 100);
+    settings.general.staleThresholdSecs = clamp(Math.round(settings.general.staleThresholdSecs), 5, 300);
+    const validCursorStyles = ['block', 'underline', 'bar'];
+    if (!validCursorStyles.includes(settings.terminal.cursorStyle)) {
+        settings.terminal.cursorStyle = 'block';
+    }
+    // Strip trailing slashes from JIRA base URL
+    if (settings.jira?.baseUrl) {
+        settings.jira.baseUrl = settings.jira.baseUrl.replace(/\/+$/, '');
+    }
+    return settings;
+}
+export class SettingsManager {
+    settings;
+    filePath;
+    constructor() {
+        this.filePath = path.join(getMobDir(), 'settings.json');
+        this.settings = this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const raw = fs.readFileSync(this.filePath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                const merged = mergeWithDefaults(parsed);
+                return validate(merged);
+            }
+        }
+        catch (err) {
+            log.error('Failed to load settings, using defaults:', err);
+        }
+        return structuredClone(DEFAULT_SETTINGS);
+    }
+    save() {
+        const tmpPath = this.filePath + '.tmp';
+        try {
+            fs.writeFileSync(tmpPath, JSON.stringify(this.settings, null, 2), 'utf-8');
+            fs.renameSync(tmpPath, this.filePath);
+        }
+        catch (err) {
+            log.error('Failed to save settings:', err);
+            // Clean up tmp file if rename failed
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch { }
+        }
+    }
+    get() {
+        return structuredClone(this.settings);
+    }
+    getRedacted() {
+        const copy = structuredClone(this.settings);
+        if (copy.jira) {
+            copy.jira.apiToken = this.settings.jira?.apiToken ? '••••' : '';
+        }
+        return copy;
+    }
+    update(partial) {
+        // If jira.apiToken comes in as the redacted sentinel, preserve existing token
+        if (partial.jira && partial.jira.apiToken === '••••') {
+            partial.jira.apiToken = this.settings.jira.apiToken;
+        }
+        const merged = mergeWithDefaults({ ...this.settings, ...partial });
+        // Deep merge: for each section in partial, overlay onto current
+        for (const section of Object.keys(partial)) {
+            if (typeof partial[section] === 'object' && section in merged) {
+                Object.assign(merged[section], partial[section]);
+            }
+        }
+        this.settings = validate(merged);
+        this.save();
+        return this.get();
+    }
+}

package/dist/server/server/status-reader.js

@@ -0,0 +1,29 @@
+import fs from 'fs';
+export function readStatusFile(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const data = JSON.parse(raw);
+        if (!data.id || !data.cwd || !data.lastUpdated) {
+            return null;
+        }
+        return {
+            id: data.id,
+            cwd: data.cwd,
+            gitBranch: data.gitBranch || undefined,
+            state: data.state || 'running',
+            ticket: data.ticket || undefined,
+            ticketStatus: data.ticketStatus || undefined,
+            subtask: data.subtask || undefined,
+            progress: typeof data.progress === 'number' ? data.progress : undefined,
+            currentTool: data.currentTool || undefined,
+            lastUpdated: data.lastUpdated,
+            sessionId: data.sessionId || undefined,
+            model: data.model || undefined,
+            topic: data.topic || undefined,
+            hookEvent: data.hookEvent || undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/server/terminal-state-detector.js

@@ -0,0 +1,42 @@
+// Braille spinner characters used by Claude CLI
+const SPINNER_CHARS = '⠋⠙⠚⠞⠖⠦⠴⠵⠸⠇⠏';
+// Patterns checked in priority order: waiting > running > idle
+const WAITING_PATTERNS = [
+    /\(y\/n\)/i,
+    /\[y\/n\]/i,
+    /\bapprove\b/i,
+    /\ballow\b/i,
+    /Do you want to proceed/i,
+    /\byes\b.*\bno\b/i,
+    /\baccept\b/i,
+    /\bdeny\b/i,
+];
+const RUNNING_PATTERNS = [
+    /esc to interrupt/i,
+    new RegExp(`[${SPINNER_CHARS}]`),
+];
+// Idle: bare prompt at end of output
+const IDLE_PATTERNS = [
+    />\s*$/, // Claude's `> ` prompt
+    /\$\s*$/, // Shell `$ ` prompt
+];
+export function detectStateFromTerminal(scrollbackTail) {
+    if (!scrollbackTail || scrollbackTail.length === 0)
+        return null;
+    // Check waiting patterns first (highest priority)
+    for (const pattern of WAITING_PATTERNS) {
+        if (pattern.test(scrollbackTail))
+            return 'waiting';
+    }
+    // Check running patterns
+    for (const pattern of RUNNING_PATTERNS) {
+        if (pattern.test(scrollbackTail))
+            return 'running';
+    }
+    // Check idle patterns (only match end of output)
+    for (const pattern of IDLE_PATTERNS) {
+        if (pattern.test(scrollbackTail))
+            return 'idle';
+    }
+    return null;
+}

package/dist/server/server/types.js

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

package/dist/server/server/util/id.js

@@ -0,0 +1,4 @@
+import crypto from 'crypto';
+export function generateInstanceId() {
+    return `mob-${crypto.randomUUID()}`;
+}

package/dist/server/server/util/logger.js

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const logFile = path.join(os.homedir(), '.mob', 'server.log');
+function appendToFile(line) {
+    try {
+        fs.appendFileSync(logFile, line + '\n');
+    }
+    catch { }
+}
+export function createLogger(module) {
+    function format(...args) {
+        const ts = new Date().toISOString().slice(11, 23);
+        return [`[${ts}] [${module}]`, ...args];
+    }
+    function formatString(...args) {
+        const ts = new Date().toISOString().slice(11, 23);
+        return `[${ts}] [${module}] ${args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')}`;
+    }
+    return {
+        info(...args) {
+            console.log(...format(...args));
+            appendToFile(formatString(...args));
+        },
+        warn(...args) {
+            console.warn(...format(...args));
+            appendToFile('WARN ' + formatString(...args));
+        },
+        error(...args) {
+            console.error(...format(...args));
+            appendToFile('ERROR ' + formatString(...args));
+        },
+    };
+}

package/dist/server/server/util/platform.js

@@ -0,0 +1,48 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import { execFileSync } from 'child_process';
+export function getDefaultShell() {
+    if (process.platform === 'win32') {
+        return process.env.COMSPEC || 'powershell.exe';
+    }
+    return process.env.SHELL || '/bin/bash';
+}
+export function getShellArgs(shell) {
+    if (shell.includes('powershell') || shell.includes('pwsh')) {
+        return ['-NoLogo'];
+    }
+    return [];
+}
+export function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+export function getMobDir() {
+    return path.join(os.homedir(), '.mob');
+}
+export function getInstancesDir() {
+    return path.join(getMobDir(), 'instances');
+}
+export function getSessionsDir() {
+    return path.join(getMobDir(), 'sessions');
+}
+export function getScrollbackDir() {
+    return path.join(getMobDir(), 'scrollback');
+}
+export function getGitBranch(cwd) {
+    try {
+        let resolved = cwd;
+        if (resolved.startsWith('~/') || resolved === '~') {
+            resolved = os.homedir() + resolved.slice(1);
+        }
+        return execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            cwd: resolved,
+            encoding: 'utf-8',
+            timeout: 3000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/server/server/util/sanitize.js

@@ -0,0 +1,126 @@
+import os from 'os';
+import path from 'path';
+// --- Shell quoting ---
+/** Wrap a value in single quotes with proper escaping for safe shell interpolation. */
+export function shellQuote(s) {
+    return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+// --- Field validators ---
+const MODEL_PATTERN = /^[a-zA-Z0-9._:/-]+$/;
+const SESSION_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+const INSTANCE_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+const VALID_PERMISSION_MODES = ['default', 'plan', 'bypassPermissions', 'full'];
+export function isValidModel(s) {
+    return MODEL_PATTERN.test(s) && s.length <= 100;
+}
+export function isValidPermissionMode(s) {
+    return VALID_PERMISSION_MODES.includes(s);
+}
+export function isValidSessionId(s) {
+    return SESSION_ID_PATTERN.test(s) && s.length <= 200;
+}
+export function isValidInstanceId(s) {
+    return INSTANCE_ID_PATTERN.test(s) && s.length <= 100;
+}
+export function isValidCwd(s) {
+    if (!s || s.length > 1024)
+        return false;
+    if (s.includes('\0'))
+        return false;
+    // Must be absolute path or start with ~
+    return s.startsWith('/') || s.startsWith('~');
+}
+export function isValidName(s) {
+    return s.length <= 256;
+}
+/** Strip control characters (except newline/tab) from a string. */
+export function stripControlChars(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
+}
+// --- Path safety ---
+/** Check if a resolved path is within the user's home directory. */
+export function isPathWithinHome(resolved) {
+    const home = os.homedir();
+    const normalized = path.resolve(resolved);
+    return normalized === home || normalized.startsWith(home + path.sep);
+}
+export function validateLaunchPayload(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return { valid: false, error: 'Payload must be an object' };
+    }
+    const p = payload;
+    // cwd: required, valid path
+    if (typeof p.cwd !== 'string' || !isValidCwd(p.cwd)) {
+        return { valid: false, error: 'Invalid or missing cwd (must be absolute path or start with ~, max 1024 chars)' };
+    }
+    // name: optional string, max 256 chars
+    const name = typeof p.name === 'string' ? stripControlChars(p.name).slice(0, 256) : '';
+    // model: optional, must match pattern
+    if (p.model !== undefined && p.model !== '') {
+        if (typeof p.model !== 'string' || !isValidModel(p.model)) {
+            return { valid: false, error: 'Invalid model (alphanumeric, dots, colons, hyphens, slashes only)' };
+        }
+    }
+    // permissionMode: optional, must be in allowlist
+    if (p.permissionMode !== undefined && p.permissionMode !== '') {
+        if (typeof p.permissionMode !== 'string' || !isValidPermissionMode(p.permissionMode)) {
+            return { valid: false, error: `Invalid permissionMode (must be one of: ${VALID_PERMISSION_MODES.join(', ')})` };
+        }
+    }
+    return {
+        valid: true,
+        data: {
+            name,
+            autoName: !!p.autoName,
+            cwd: p.cwd,
+            model: (typeof p.model === 'string' && p.model) || undefined,
+            permissionMode: (typeof p.permissionMode === 'string' && p.permissionMode) || undefined,
+        },
+    };
+}
+export function validateHookPayload(data) {
+    if (!data || typeof data !== 'object') {
+        return { valid: false, error: 'Payload must be an object' };
+    }
+    const d = data;
+    // id: required
+    if (typeof d.id !== 'string' || !d.id) {
+        return { valid: false, error: 'Missing instance id' };
+    }
+    if (d.id.length > 200) {
+        return { valid: false, error: 'Instance id too long' };
+    }
+    // cwd: optional but if present must be valid
+    if (d.cwd !== undefined && typeof d.cwd === 'string') {
+        if (d.cwd.includes('\0') || d.cwd.length > 1024) {
+            return { valid: false, error: 'Invalid cwd' };
+        }
+    }
+    // sessionId: optional, alphanumeric
+    if (d.sessionId !== undefined && typeof d.sessionId === 'string') {
+        if (!isValidSessionId(d.sessionId)) {
+            return { valid: false, error: 'Invalid sessionId format' };
+        }
+    }
+    // model: optional
+    if (d.model !== undefined && typeof d.model === 'string' && d.model !== '') {
+        if (!isValidModel(d.model)) {
+            return { valid: false, error: 'Invalid model format' };
+        }
+    }
+    // Strip control chars from string fields
+    if (typeof d.name === 'string')
+        d.name = stripControlChars(d.name).slice(0, 256);
+    if (typeof d.subtask === 'string')
+        d.subtask = stripControlChars(d.subtask).slice(0, 500);
+    if (typeof d.topic === 'string')
+        d.topic = stripControlChars(d.topic).slice(0, 500);
+    if (typeof d.ticket === 'string')
+        d.ticket = stripControlChars(d.ticket).slice(0, 200);
+    if (typeof d.ticketStatus === 'string')
+        d.ticketStatus = stripControlChars(d.ticketStatus).slice(0, 100);
+    if (typeof d.hookEvent === 'string')
+        d.hookEvent = stripControlChars(d.hookEvent).slice(0, 50);
+    return { valid: true, data: d };
+}