@supen-ai/cli 0.1.13 → 1.3.2

package/daemon/dist/http/routes/system.js

@@ -1766,10 +1766,6 @@ const MANAGED_CODING_CLI_INSTALL_COMMANDS = {
 };
 const CODING_CLI_NAMES = ['codex', 'gemini', 'claude'];
 const DETECTABLE_SPACE_APPS = [
-    { id: 'codex', command: 'codex', managed: true },
-    { id: 'gemini', command: 'gemini', managed: true },
-    { id: 'claude', command: 'claude', managed: false },
-    { id: 'acpx', command: 'acpx', managed: false },
     { id: 'libreoffice', command: 'libreoffice', managed: false },
     { id: 'dotnet', command: 'dotnet', managed: false },
     { id: 'tiwater-docx', command: 'tiwater-docx', managed: false },
@@ -2053,15 +2049,47 @@ function detectCodexAuthStatus(installed) {
         ? email || accountLine || 'Authenticated'
         : null;
     let accountId = null;
+    let tokenEmail = null;
+    let tokenName = null;
     try {
         const parsed = JSON.parse(fs.readFileSync(path.join(resolveCodexHome(), 'auth.json'), 'utf8'));
         const tokens = parsed.tokens && typeof parsed.tokens === 'object' ? parsed.tokens : {};
         accountId = typeof tokens.account_id === 'string' && tokens.account_id.trim() ? tokens.account_id.trim() : null;
+        const identity = codexIdentityClaimsFromIdToken(tokens.id_token);
+        tokenEmail = identity.email;
+        tokenName = identity.name;
     }
     catch {
         accountId = null;
     }
-    return { authenticated, summary, account_id: accountId };
+    return {
+        authenticated,
+        summary: authenticated ? tokenEmail || email || tokenName || accountLine || 'Authenticated' : null,
+        account_id: accountId,
+        email: tokenEmail || email || null,
+        name: tokenName,
+    };
+}
+function codexIdentityClaimsFromIdToken(idToken) {
+    if (typeof idToken !== 'string' || !idToken.trim())
+        return { email: null, name: null };
+    const payload = idToken.split('.')[1];
+    if (!payload)
+        return { email: null, name: null };
+    try {
+        const decoded = Buffer.from(payload.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8');
+        const claims = JSON.parse(decoded);
+        const email = typeof claims.email === 'string' && claims.email.trim()
+            ? claims.email.trim()
+            : null;
+        const name = typeof claims.name === 'string' && claims.name.trim()
+            ? claims.name.trim()
+            : null;
+        return { email, name };
+    }
+    catch {
+        return { email: null, name: null };
+    }
 }
 function readCodexDefaultModel() {
     const codexHome = resolveCodexHome();
@@ -2277,6 +2305,23 @@ function readCodingCliStatusPayload() {
         codex_connect: codexConnectSnapshot(),
     };
 }
+function readInstalledAppsPayload() {
+    return {
+        installed_apps: DETECTABLE_SPACE_APPS.map((app) => {
+            const detected = detectCliInstalled(app.command);
+            return {
+                id: app.id,
+                installed: detected.installed,
+                version: detected.version,
+                managed: app.managed,
+                path: detected.path,
+                resolved_path: detected.resolved_path,
+                install_source: detected.install_source,
+                update_supported: detected.update_supported,
+            };
+        }),
+    };
+}
 function readCachedCodingCliStatusPayload(options) {
     startCodingCliStatusCache({
         build: () => ({
@@ -2286,6 +2331,111 @@ function readCachedCodingCliStatusPayload(options) {
     });
     return getCodingCliStatusResponse(options);
 }
+function mergeQuotaWindows(...groups) {
+    const byLabel = new Map();
+    for (const group of groups) {
+        for (const window of group) {
+            const key = window.label.trim().toLowerCase();
+            if (!key)
+                continue;
+            byLabel.set(key, window);
+        }
+    }
+    return Array.from(byLabel.values());
+}
+function resetAtFromCodexValue(value) {
+    if (typeof value === 'string' && value.trim())
+        return value.trim();
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        const millis = value > 10_000_000_000 ? value : value * 1000;
+        return new Date(millis).toISOString();
+    }
+    return null;
+}
+function quotaLabelForCodexWindow(key, record) {
+    const duration = numberValue(record.windowDurationMins);
+    if (duration === 300)
+        return '5-hour limit';
+    if (duration === 10080)
+        return 'Weekly limit';
+    return key === 'primary' ? 'Primary limit' : key === 'secondary' ? 'Secondary limit' : labelForQuotaWindow(key, record);
+}
+function quotaWindowFromCodexNestedRecord(key, value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const record = value;
+    const percent = numberValue(record.usedPercent ?? record.used_percent ?? record.percent);
+    const reset_at = resetAtFromCodexValue(record.resetsAt ?? record.resetAt ?? record.reset_at ?? record.reset);
+    if (percent === null && !reset_at)
+        return null;
+    return {
+        label: quotaLabelForCodexWindow(key, record),
+        used: null,
+        limit: null,
+        remaining: null,
+        percent,
+        reset_at,
+    };
+}
+function normalizeCodexSubscriptionQuotaWindows(subscription) {
+    const rateLimits = subscription.rate_limits && typeof subscription.rate_limits === 'object'
+        ? subscription.rate_limits
+        : null;
+    if (!rateLimits)
+        return [];
+    return ['primary', 'secondary']
+        .map((key) => quotaWindowFromCodexNestedRecord(key, rateLimits[key]))
+        .filter((entry) => Boolean(entry));
+}
+function codexSubscriptionSummary(subscription) {
+    const rateLimits = subscription.rate_limits && typeof subscription.rate_limits === 'object'
+        ? subscription.rate_limits
+        : {};
+    const credits = rateLimits.credits && typeof rateLimits.credits === 'object'
+        ? rateLimits.credits
+        : {};
+    return {
+        plan_type: typeof rateLimits.planType === 'string' && rateLimits.planType.trim() ? rateLimits.planType.trim() : null,
+        credits_balance: typeof credits.balance === 'string' && credits.balance.trim() ? credits.balance.trim() : null,
+    };
+}
+async function readCodexAgentStatusPayload() {
+    const status = readCachedCodingCliStatusPayload();
+    const quotaStatus = readLatestSpaceQuotaStatus();
+    try {
+        const subscription = await readCodexSubscription();
+        const subscriptionWindows = mergeQuotaWindows(normalizeCodexSubscriptionQuotaWindows(subscription), normalizeQuotaWindows(subscription.rate_limits), normalizeQuotaWindows(subscription.rate_limits_by_limit_id));
+        return {
+            ...status,
+            subscription: {
+                ok: true,
+                fetched_at: subscription.fetched_at,
+                payload: subscription,
+                error: null,
+            },
+            subscription_summary: codexSubscriptionSummary(subscription),
+            quota_status: quotaStatus,
+            quota_windows: mergeQuotaWindows(quotaStatus.windows, subscriptionWindows),
+        };
+    }
+    catch (err) {
+        return {
+            ...status,
+            subscription: {
+                ok: false,
+                fetched_at: null,
+                payload: null,
+                error: err?.message || 'Unable to read Codex subscription details.',
+            },
+            subscription_summary: {
+                plan_type: null,
+                credits_balance: null,
+            },
+            quota_status: quotaStatus,
+            quota_windows: quotaStatus.windows,
+        };
+    }
+}
 function readRuntimeModelStatusPayload() {
     const selected_cli = process.env.SUPEN_CODING_CLI || readConfigSummary().coding_cli || 'codex';
     const codexTransport = normalizeCodexTransport(process.env.SUPEN_CODEX_TRANSPORT) ||
@@ -2606,7 +2756,11 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         return true;
     }
     if (pathname === '/api/computers/{computer_id}/apps' && method === 'GET') {
-        writeJson(res, 200, readCachedCodingCliStatusPayload());
+        writeJson(res, 200, readInstalledAppsPayload());
+        return true;
+    }
+    if (pathname === '/api/computers/{computer_id}/agents/codex' && method === 'GET') {
+        writeJson(res, 200, await readCodexAgentStatusPayload());
         return true;
     }
     if (pathname === '/api/computers/{computer_id}/runtime-models' && method === 'GET') {
@@ -2634,10 +2788,10 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         }
         return true;
     }
-    const spaceCodexTransportDefaultMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/apps\/codex\/transports\/([^/]+)\/default$/);
-    if (spaceCodexTransportDefaultMatch && method === 'PUT') {
+    const codexTransportDefaultMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/codex\/transports\/([^/]+)\/default$/);
+    if (codexTransportDefaultMatch && method === 'PUT') {
         try {
-            const transport = normalizeCodexTransport(decodeURIComponent(spaceCodexTransportDefaultMatch[1] || '').trim());
+            const transport = normalizeCodexTransport(decodeURIComponent(codexTransportDefaultMatch[1] || '').trim());
             if (!transport) {
                 writeProtocolError(res, 400, 'validation_error', 'invalid_codex_transport', 'transport must be one of: app-server, exec, acpx');
                 return true;
@@ -2654,15 +2808,9 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         }
         return true;
     }
-    const spaceAppDefaultMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/apps\/([^/]+)\/default$/);
-    if (spaceAppDefaultMatch && method === 'PUT') {
+    if (pathname === '/api/computers/{computer_id}/agents/codex/default' && method === 'PUT') {
         try {
-            const cli = normalizeCliName(decodeURIComponent(spaceAppDefaultMatch[1] || '').trim());
-            if (!cli) {
-                writeProtocolError(res, 400, 'validation_error', 'invalid_cli', 'cli must be one of: codex, gemini, claude');
-                return true;
-            }
-            const result = setDefaultCodingCli(cli);
+            const result = setDefaultCodingCli('codex');
             writeJson(res, 200, {
                 ok: true,
                 ...result,
@@ -2670,28 +2818,19 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
             });
         }
         catch (err) {
-            writeProtocolError(res, 500, 'config_error', 'coding_cli_default_failed', err?.message || 'Failed to set default coding CLI');
+            writeProtocolError(res, 500, 'config_error', 'coding_agent_default_failed', err?.message || 'Failed to set default coding agent');
         }
         return true;
     }
-    const spaceAppInstallMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/apps\/([^/]+)\/install$/);
-    if (spaceAppInstallMatch && method === 'POST') {
+    if (pathname === '/api/computers/{computer_id}/agents/codex/install' && method === 'POST') {
         try {
-            const cli = normalizeCliName(decodeURIComponent(spaceAppInstallMatch[1] || '').trim());
-            if (!cli) {
-                writeProtocolError(res, 400, 'validation_error', 'invalid_cli', 'cli must be one of: codex, gemini, claude');
-                return true;
-            }
-            if (!isManagedCliName(cli)) {
-                writeProtocolError(res, 400, 'validation_error', 'install_not_supported', 'Only codex and gemini support managed install at the moment');
-                return true;
-            }
+            const cli = 'codex';
             const current = detectCliInstalled(cli);
             if (current.installed && !current.update_supported) {
                 writeProtocolError(res, 400, 'validation_error', 'coding_cli_update_not_supported', `${cli} is installed via ${current.install_source || current.resolved_path || current.path || 'an unknown source'}; update it with that installer on this computer.`);
                 return true;
             }
-            const installSpec = MANAGED_CODING_CLI_INSTALL_COMMANDS[cli];
+            const installSpec = MANAGED_CODING_CLI_INSTALL_COMMANDS.codex;
             const result = spawnSync(installSpec.command, installSpec.args, {
                 encoding: 'utf8',
                 timeout: 120_000,
@@ -2749,13 +2888,7 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         }
         return true;
     }
-    const spaceAppConnectMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/apps\/([^/]+)\/connect$/);
-    if (spaceAppConnectMatch && method === 'POST') {
-        const cli = normalizeCliName(decodeURIComponent(spaceAppConnectMatch[1] || '').trim());
-        if (cli !== 'codex') {
-            writeProtocolError(res, 400, 'validation_error', 'connect_not_supported', 'Only codex supports connect flow at the moment');
-            return true;
-        }
+    if (pathname === '/api/computers/{computer_id}/agents/codex/connect' && method === 'POST') {
         const status = readCachedCodingCliStatusPayload();
         const codex = status.clis.find((entry) => entry.name === 'codex');
         if (!codex?.installed) {
@@ -2769,12 +2902,7 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         });
         return true;
     }
-    if (spaceAppConnectMatch && method === 'DELETE') {
-        const cli = normalizeCliName(decodeURIComponent(spaceAppConnectMatch[1] || '').trim());
-        if (cli !== 'codex') {
-            writeProtocolError(res, 400, 'validation_error', 'connect_not_supported', 'Only codex supports connect flow at the moment');
-            return true;
-        }
+    if (pathname === '/api/computers/{computer_id}/agents/codex/connect' && method === 'DELETE') {
         writeJson(res, 200, {
             ok: true,
             codex_connect: cancelCodexConnectFlow(),
@@ -2782,13 +2910,7 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         });
         return true;
     }
-    const spaceAppSessionMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/apps\/([^/]+)\/session$/);
-    if (spaceAppSessionMatch && method === 'DELETE') {
-        const cli = normalizeCliName(decodeURIComponent(spaceAppSessionMatch[1] || '').trim());
-        if (cli !== 'codex') {
-            writeProtocolError(res, 400, 'validation_error', 'session_not_supported', 'Only codex supports session connect/disconnect at the moment');
-            return true;
-        }
+    if (pathname === '/api/computers/{computer_id}/agents/codex/session' && method === 'DELETE') {
         const cmd = spawnSync('codex', ['logout'], {
             encoding: 'utf8',
             timeout: 15_000,
@@ -2832,19 +2954,6 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         writeJson(res, 200, { daily: getDailyUsage() });
         return true;
     }
-    if (pathname === '/api/computers/{computer_id}/codex/subscription' && method === 'GET') {
-        try {
-            writeJson(res, 200, await readCodexSubscription());
-        }
-        catch (err) {
-            writeProtocolError(res, 503, 'service_unavailable', 'codex_subscription_unavailable', err?.message || 'Unable to read Codex subscription details.');
-        }
-        return true;
-    }
-    if (pathname === '/api/computers/{computer_id}/quota-status' && method === 'GET') {
-        writeJson(res, 200, readLatestSpaceQuotaStatus());
-        return true;
-    }
     if (pathname === '/api/computers/{computer_id}/codex/threads' && method === 'GET') {
         const limitRaw = coerceSingleQueryParam(url.searchParams.get('limit'));
         const limit = limitRaw ? Number.parseInt(limitRaw, 10) : MIRRORED_THREAD_LIMIT;