fraim-hub 2.0.204

package/dist/src/ai-hub/cli.js

@@ -0,0 +1,212 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHub = runHub;
+// Hub-owned launcher used by the fraim-hub package. Keep this outside
+// src/cli/commands so the core fraim package has no Hub command implementation.
+const git_utils_1 = require("../core/utils/git-utils");
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const net_1 = __importDefault(require("net"));
+const http_1 = __importDefault(require("http"));
+const hub_launch_decision_1 = require("./hub-launch-decision");
+const hub_runtime_file_1 = require("./hub-runtime-file");
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const version_utils_1 = require("../cli/utils/version-utils");
+function resolveElectronBinary() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require('electron');
+    }
+    catch {
+        return null;
+    }
+}
+function resolveDesktopEntry() {
+    const candidates = [
+        path_1.default.resolve(__dirname, 'desktop-main.js'),
+        path_1.default.resolve(process.cwd(), 'dist', 'src', 'ai-hub', 'desktop-main.js'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            fs_1.default.accessSync(candidate);
+            return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function openDesktopWindow(projectPath, preferredPort) {
+    const electronBinary = resolveElectronBinary();
+    const desktopEntry = resolveDesktopEntry();
+    if (!electronBinary || !desktopEntry) {
+        return false;
+    }
+    const child = (0, child_process_1.spawn)(electronBinary, [desktopEntry, '--project-path', projectPath, '--port', String(preferredPort)], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    return true;
+}
+function openBrowser(url) {
+    if (process.platform === 'win32') {
+        const child = (0, child_process_1.spawn)('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' });
+        child.unref();
+        return;
+    }
+    if (process.platform === 'darwin') {
+        const child = (0, child_process_1.spawn)('open', [url], { detached: true, stdio: 'ignore' });
+        child.unref();
+        return;
+    }
+    const child = (0, child_process_1.spawn)('xdg-open', [url], { detached: true, stdio: 'ignore' });
+    child.unref();
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return !!(e && e.code === 'EPERM');
+    }
+}
+function killPid(pid) {
+    try {
+        if (process.platform === 'win32') {
+            (0, child_process_1.execFileSync)('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
+        }
+        else {
+            process.kill(pid, 'SIGTERM');
+        }
+    }
+    catch {
+        /* already gone */
+    }
+}
+function isPortFree(port, timeoutMs = 500) {
+    return new Promise((resolve) => {
+        const sock = net_1.default.connect({ host: '127.0.0.1', port }, () => { sock.destroy(); resolve(false); });
+        sock.on('error', () => resolve(true));
+        sock.setTimeout(timeoutMs, () => { sock.destroy(); resolve(true); });
+    });
+}
+async function waitForPortFree(port, totalMs = 5000) {
+    const start = Date.now();
+    while (Date.now() - start < totalMs) {
+        if (await isPortFree(port))
+            return;
+        await new Promise((r) => setTimeout(r, 200));
+    }
+}
+function fetchRunningHubVersion(port) {
+    return new Promise((resolve) => {
+        const req = http_1.default.get({ host: '127.0.0.1', port, path: '/api/ai-hub/version', timeout: 1000 }, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume();
+                return resolve(null);
+            }
+            let body = '';
+            res.on('data', (c) => { body += c; });
+            res.on('end', () => { try {
+                resolve(JSON.parse(body).version ?? null);
+            }
+            catch {
+                resolve(null);
+            } });
+        });
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+}
+async function reconcileRunningHub(flags) {
+    const running = (0, hub_runtime_file_1.readHubRuntimeFile)((0, project_fraim_paths_1.getUserFraimDirPath)());
+    const confirmedVersion = running ? await fetchRunningHubVersion(running.port) : null;
+    const live = !!(running && confirmedVersion && isProcessAlive(running.pid));
+    const effective = live && running ? { ...running, version: confirmedVersion } : null;
+    const decision = (0, hub_launch_decision_1.decideHubLaunch)({
+        running: effective,
+        pidAlive: live,
+        cliVersion: (0, version_utils_1.getFraimVersion)(),
+        restart: flags.restart,
+        noRestart: flags.keepRunning,
+    });
+    if (decision.action === 'replace' && effective) {
+        console.log(`Replacing running Hub (v${effective.version}, pid ${effective.pid}) - ${decision.reason}`);
+        killPid(effective.pid);
+        await waitForPortFree(effective.port);
+    }
+    else if (decision.action === 'focus-existing' && effective) {
+        console.log(`A Hub (v${effective.version}) is already running - focusing it. Use --restart to replace it.`);
+    }
+}
+async function runHub(options) {
+    const { AiHubServer, findAvailablePort } = await Promise.resolve().then(() => __importStar(require('./server')));
+    const preferredPort = options.port || (0, git_utils_1.getPort)() + 100;
+    const projectPath = path_1.default.resolve(options.projectPath || process.cwd());
+    if (options.open) {
+        const wantDesktop = !options.browser;
+        if (wantDesktop) {
+            await reconcileRunningHub({ restart: !!options.restart, keepRunning: !!options.keepRunning });
+        }
+        const openedDesktop = wantDesktop && openDesktopWindow(projectPath, preferredPort);
+        if (!openedDesktop) {
+            const port = await findAvailablePort(preferredPort);
+            const server = new AiHubServer({ projectPath });
+            await server.start(port);
+            const url = `http://127.0.0.1:${port}/ai-hub/`;
+            console.log(`AI Hub running at ${url}`);
+            console.log(`Project path: ${projectPath}`);
+            openBrowser(url);
+            return;
+        }
+        console.log('AI Hub desktop shell launched.');
+        console.log(`Project path: ${projectPath}`);
+        return;
+    }
+    const port = await findAvailablePort(preferredPort);
+    const server = new AiHubServer({ projectPath });
+    await server.start(port);
+    const url = `http://127.0.0.1:${port}/ai-hub/`;
+    console.log(`AI Hub running at ${url}`);
+    console.log(`Project path: ${projectPath}`);
+}

package/dist/src/ai-hub/configured-agents.js

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiHubConfiguredAgentStore = void 0;
+exports.synthesizeDefaultConfiguredAgents = synthesizeDefaultConfiguredAgents;
+exports.checkConfiguredAgentAvailability = checkConfiguredAgentAvailability;
+exports.projectConfiguredAgent = projectConfiguredAgent;
+exports.resolveConfiguredAgentForHost = resolveConfiguredAgentForHost;
+exports.resolveConfiguredAgentEnv = resolveConfiguredAgentEnv;
+exports.decorateHostPlanWithConfiguredAgent = decorateHostPlanWithConfiguredAgent;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const VALID_HOSTS = ['codex', 'claude', 'gemini', 'copilot'];
+const ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function nowIso() {
+    return new Date().toISOString();
+}
+function storePath() {
+    return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'hub-configured-agents.json');
+}
+function normalizeId(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((item) => String(item || '').trim()).filter(Boolean);
+}
+function normalizeAgent(input) {
+    const id = normalizeId(input.id);
+    const label = String(input.label || '').trim();
+    const baseHostId = input.baseHostId;
+    if (!id)
+        return { ok: false, error: 'Configured agent id is required.' };
+    if (!label)
+        return { ok: false, error: 'Configured agent label is required.' };
+    if (!VALID_HOSTS.includes(baseHostId))
+        return { ok: false, error: 'Choose a supported base agent.' };
+    const setupScript = normalizeSetupScript(input.setupScript);
+    if (input.setupScript && !setupScript)
+        return { ok: false, error: 'Setup script command is required.' };
+    const createdAt = input.createdAt || nowIso();
+    return {
+        ok: true,
+        agent: {
+            id,
+            label,
+            ...(input.description && String(input.description).trim() ? { description: String(input.description).trim() } : {}),
+            baseHostId,
+            enabled: input.enabled !== false,
+            ...(setupScript ? { setupScript } : {}),
+            createdAt,
+            updatedAt: nowIso(),
+        },
+    };
+}
+function normalizeSetupScript(value) {
+    if (!value)
+        return null;
+    const runner = value.runner;
+    const command = String(value.command || '').trim();
+    if (!['powershell', 'bash'].includes(runner) || !command)
+        return null;
+    return {
+        runner,
+        command,
+        args: stringArray(value.args),
+        timeoutMs: typeof value.timeoutMs === 'number' && value.timeoutMs > 0 ? Math.min(value.timeoutMs, 120_000) : 30_000,
+    };
+}
+function synthesizeDefaultConfiguredAgents(employees) {
+    const timestamp = '1970-01-01T00:00:00.000Z';
+    return employees.map((employee) => ({
+        id: `${employee.id}-default`,
+        label: employee.label,
+        description: 'Default local launch for this agent tool.',
+        baseHostId: employee.id,
+        enabled: true,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+    }));
+}
+class AiHubConfiguredAgentStore {
+    constructor(filePath = storePath()) {
+        this.filePath = filePath;
+    }
+    list() {
+        try {
+            if (!fs_1.default.existsSync(this.filePath))
+                return [];
+            const parsed = JSON.parse(fs_1.default.readFileSync(this.filePath, 'utf8'));
+            if (!Array.isArray(parsed))
+                return [];
+            return parsed
+                .map((item) => normalizeAgent(item))
+                .filter((result) => result.ok && !!result.agent)
+                .map((result) => result.agent);
+        }
+        catch {
+            return [];
+        }
+    }
+    listWithDefaults(employees) {
+        const persisted = this.list();
+        const defaults = synthesizeDefaultConfiguredAgents(employees);
+        const seen = new Set(persisted.map((agent) => agent.id));
+        return [...persisted, ...defaults.filter((agent) => !seen.has(agent.id))];
+    }
+    upsert(input) {
+        const existing = this.list().find((agent) => agent.id === normalizeId(input.id));
+        const normalized = normalizeAgent({ ...input, createdAt: existing?.createdAt || input.createdAt });
+        if (!normalized.ok || !normalized.agent)
+            return normalized;
+        const list = this.list().filter((agent) => agent.id !== normalized.agent.id);
+        list.push(normalized.agent);
+        this.save(list);
+        return normalized;
+    }
+    delete(id) {
+        const normalizedId = normalizeId(id);
+        if (!normalizedId || normalizedId.endsWith('-default'))
+            return false;
+        const list = this.list();
+        const next = list.filter((agent) => agent.id !== normalizedId);
+        if (next.length === list.length)
+            return false;
+        this.save(next);
+        return true;
+    }
+    save(agents) {
+        fs_1.default.mkdirSync(path_1.default.dirname(this.filePath), { recursive: true });
+        fs_1.default.writeFileSync(this.filePath, JSON.stringify(agents, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+    }
+}
+exports.AiHubConfiguredAgentStore = AiHubConfiguredAgentStore;
+function checkConfiguredAgentAvailability(agent, employees, env = process.env) {
+    const reasons = [];
+    const warnings = [];
+    const employee = employees.find((entry) => entry.id === agent.baseHostId);
+    if (!agent.enabled)
+        reasons.push('Configured agent is disabled.');
+    if (!employee?.available)
+        reasons.push(`${employee?.label || agent.baseHostId} is not available on this machine.`);
+    if (agent.setupScript) {
+        const command = agent.setupScript.command;
+        const isPathLike = /[\\/]/.test(command) || /^[A-Za-z]:[\\/]/.test(command);
+        if (isPathLike && !fs_1.default.existsSync(command)) {
+            reasons.push(`Setup script is missing: ${path_1.default.basename(command)}`);
+        }
+    }
+    else if (!agent.id.endsWith('-default')) {
+        warnings.push('No setup script configured; this profile launches the base CLI unchanged.');
+    }
+    return { id: agent.id, label: agent.label, baseHostId: agent.baseHostId, enabled: agent.enabled, available: reasons.length === 0, reasons, warnings };
+}
+function projectConfiguredAgent(agent, employees) {
+    const check = checkConfiguredAgentAvailability(agent, employees);
+    return {
+        id: agent.id,
+        label: agent.label,
+        ...(agent.description ? { description: agent.description } : {}),
+        baseHostId: agent.baseHostId,
+        enabled: agent.enabled,
+        ...(agent.setupScript ? { setupScript: { ...agent.setupScript, args: [...(agent.setupScript.args || [])] } } : {}),
+        createdAt: agent.createdAt,
+        updatedAt: agent.updatedAt,
+        available: check.available,
+        reasons: check.reasons,
+        warnings: check.warnings,
+    };
+}
+function resolveConfiguredAgentForHost(configuredAgentId, hostId, agents) {
+    const explicit = configuredAgentId ? agents.find((agent) => agent.id === configuredAgentId) : undefined;
+    if (explicit)
+        return { agent: explicit, baseHostId: explicit.baseHostId };
+    const fallbackHost = hostId && VALID_HOSTS.includes(hostId) ? hostId : 'claude';
+    const fallback = agents.find((agent) => agent.id === `${fallbackHost}-default`) || {
+        id: `${fallbackHost}-default`,
+        label: fallbackHost,
+        baseHostId: fallbackHost,
+        enabled: true,
+    };
+    return { agent: fallback, baseHostId: fallback.baseHostId };
+}
+function resolveConfiguredAgentEnv(agent) {
+    if (!agent.setupScript)
+        return {};
+    return runSetupScript(agent.setupScript);
+}
+function runSetupScript(setupScript) {
+    const args = setupScript.args || [];
+    const captureEnv = {
+        ...process.env,
+        FRAIM_HUB_SETUP_SCRIPT_COMMAND: setupScript.command,
+        FRAIM_HUB_SETUP_SCRIPT_ARGS_JSON: JSON.stringify(args),
+    };
+    const invocation = setupScript.runner === 'powershell'
+        ? ['powershell.exe', [
+                '-NoProfile',
+                '-ExecutionPolicy',
+                'Bypass',
+                '-Command',
+                [
+                    '$ErrorActionPreference = "Stop";',
+                    '$before = @{};',
+                    '[Environment]::GetEnvironmentVariables("Process").GetEnumerator() | ForEach-Object { $before[$_.Key] = [string]$_.Value };',
+                    '$scriptArgs = @();',
+                    'if ($env:FRAIM_HUB_SETUP_SCRIPT_ARGS_JSON) { $scriptArgs = @(ConvertFrom-Json $env:FRAIM_HUB_SETUP_SCRIPT_ARGS_JSON); }',
+                    '. $env:FRAIM_HUB_SETUP_SCRIPT_COMMAND @scriptArgs *> $null;',
+                    '[Environment]::GetEnvironmentVariables("Process").GetEnumerator() | ForEach-Object {',
+                    '  $name = [string]$_.Key;',
+                    '  $value = [string]$_.Value;',
+                    '  if ($name -match "^[A-Za-z_][A-Za-z0-9_]*$" -and (!$before.ContainsKey($name) -or $before[$name] -ne $value)) { "$name=$value" }',
+                    '}',
+                ].join(' '),
+            ]]
+        : ['bash', [
+                '-lc',
+                [
+                    'set -e',
+                    'before="$(mktemp)"',
+                    'after="$(mktemp)"',
+                    'env | sort > "$before"',
+                    'source "$1" "${@:2}" >/dev/null',
+                    'env | sort > "$after"',
+                    'comm -13 "$before" "$after"',
+                    'rm -f "$before" "$after"',
+                ].join('; '),
+                'fraim-hub-setup',
+                setupScript.command,
+                ...args,
+            ]];
+    const result = (0, child_process_1.spawnSync)(invocation[0], invocation[1], {
+        encoding: 'utf8',
+        timeout: setupScript.timeoutMs || 30_000,
+        env: captureEnv,
+    });
+    if (result.error || result.status !== 0) {
+        const detail = result.error?.message || result.stderr?.trim() || `exit ${result.status}`;
+        throw new Error(`Configured agent setup script failed: ${detail}`);
+    }
+    return filterSafeEnv(parseEnvLines(result.stdout || ''));
+}
+function parseEnvLines(stdout) {
+    const env = {};
+    for (const line of stdout.split(/\r?\n/)) {
+        const idx = line.indexOf('=');
+        if (idx <= 0)
+            continue;
+        const key = line.slice(0, idx).trim();
+        const value = line.slice(idx + 1);
+        if (ENV_NAME_PATTERN.test(key))
+            env[key] = value;
+    }
+    return env;
+}
+function filterSafeEnv(env) {
+    const safe = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (!ENV_NAME_PATTERN.test(key))
+            continue;
+        if (key.startsWith('FRAIM_HUB_SETUP_SCRIPT_'))
+            continue;
+        safe[key] = value;
+    }
+    return safe;
+}
+function decorateHostPlanWithConfiguredAgent(plan, agent, agentEnv = {}) {
+    if (!agent)
+        return plan;
+    return {
+        ...plan,
+        env: { ...agentEnv, ...(plan.env || {}) },
+    };
+}