@sireai/optimus 0.1.8 → 0.1.9

package/README.md

@@ -35,7 +35,7 @@ npx playwright install chromium
 optimus setup
 ```
 
-Setup creates the `~/.optimus` runtime home, registers the first repository, configures Codex authentication, and records Jira, Sentry, and Feishu integration settings. When Jira and Sentry are both enabled, setup also stores the Jira project key used to auto-create Jira issues for Sentry-origin patch publication.
+Setup creates the `~/.optimus` runtime home, registers the first repository, configures Codex authentication, and records Jira, Sentry, and Feishu delivery settings. If Feishu delivery is enabled, run `optimus feishu auth login` after setup to enable analysis-doc upload and real @mentions. When Jira and Sentry are both enabled, setup also stores the Jira project key used to auto-create Jira issues for Sentry-origin patch publication.
 
 Supported Codex auth modes:
 
@@ -76,6 +76,7 @@ optimus setup
 optimus doctor --quick
 optimus start
 optimus submit --title "..." --description "..."
+optimus feishu auth login
 ```
 
 Task inspection:

package/dist/cli/optimus.js

@@ -29,6 +29,7 @@ import { TaskDeliveryDispatcher } from "../task-environment/delivery/task-delive
 import { TaskDeliveryService } from "../task-environment/delivery/task-delivery-service.js";
 import { FeishuAnalysisDocService } from "../task-environment/delivery/feishu-analysis-doc-service.js";
 import { TaskPublicationService } from "../task-environment/delivery/task-publication-service.js";
+import { FeishuAuthService } from "../integrations/feishu/feishu-auth-service.js";
 import { resolveDefaultConfigPath, resolveDefaultEnvPath, resolveOptimusHomeDir } from "../config/optimus-paths.js";
 import { checkForSelfUpdate, installSelfUpdate, recordSkippedSelfUpdate, readSelfUpdateState, shouldPromptForCachedStartupUpdate } from "./self-update.js";
 const CLI_ROOT_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
@@ -165,6 +166,7 @@ function renderCliHelp() {
         "  postrun-retry         Rebuild postrun artifacts and optionally replay publication",
         "",
         "Integration commands:",
+        "  feishu auth login|status|logout",
         "  jira-search|jira-get-issue|jira-search-assigned-open|jira-submit-issue|jira-submit-assigned-open|jira-add-comment|jira-refresh-auth|jira-poll-once|jira-poll-daemon",
         "  sentry-get-event|sentry-submit-event",
         "  Example: optimus help jira-submit-issue",
@@ -315,6 +317,32 @@ function renderCommandHelp(command) {
             "  optimus upgrade --check --channel snapshot",
             "  optimus upgrade --channel snapshot"
         ].join("\n"),
+        feishu: [
+            "optimus feishu auth",
+            "",
+            "Usage:",
+            "  optimus feishu auth login [--json]",
+            "  optimus feishu auth status [--json]",
+            "  optimus feishu auth logout",
+            "",
+            "Notes:",
+            "  - `login` starts Feishu device-code login for document upload and real @mentions.",
+            "  - `status` shows whether the current Optimus Feishu session is still valid.",
+            "  - `logout` clears the local Optimus Feishu auth token."
+        ].join("\n"),
+        "feishu auth": [
+            "optimus feishu auth",
+            "",
+            "Usage:",
+            "  optimus feishu auth login [--json]",
+            "  optimus feishu auth status [--json]",
+            "  optimus feishu auth logout",
+            "",
+            "Notes:",
+            "  - `login` starts Feishu device-code login for document upload and real @mentions.",
+            "  - `status` shows whether the current Optimus Feishu session is still valid.",
+            "  - `logout` clears the local Optimus Feishu auth token."
+        ].join("\n"),
         "jira-submit-issue": [
             "optimus jira-submit-issue",
             "",
@@ -813,83 +841,58 @@ function buildPublicationReviewSummary(attempts) {
         }
     };
 }
-function buildFeishuEnvStatus() {
+async function buildFeishuDoctorStatus(config) {
+    const webhookConfigured = Boolean(config.delivery.feishu.webhook?.trim() || config.delivery.feishu.webhooks?.some((value) => value.trim()));
+    const authStatus = new FeishuAuthService().readStatus();
+    const hasAppId = Boolean(config.delivery.feishu.appId?.trim() || process.env.FEISHU_APP_ID?.trim());
+    const hasAppSecret = Boolean(config.delivery.feishu.appSecret?.trim() || process.env.FEISHU_APP_SECRET?.trim());
+    const appCredentialConfigured = hasAppId && hasAppSecret;
+    const authReady = authStatus.authenticated || appCredentialConfigured;
+    const authMode = authStatus.authenticated
+        ? "user_access_token"
+        : appCredentialConfigured
+            ? "app_credentials"
+            : "none";
     return {
-        webhook: Boolean(process.env.OPTIMUS_FEISHU_WEBHOOK?.trim()),
-        webhooks: Boolean(process.env.OPTIMUS_FEISHU_WEBHOOKS?.trim()),
-        secret: Boolean(process.env.OPTIMUS_FEISHU_SECRET?.trim())
+        webhook: {
+            configured: webhookConfigured,
+            signed: Boolean(config.delivery.feishu.secret?.trim())
+        },
+        auth: {
+            configured: authReady,
+            baseUrl: authStatus.baseUrl,
+            mode: authMode,
+            accessTokenExpired: authStatus.accessTokenExpired,
+            refreshTokenExpired: authStatus.refreshTokenExpired,
+            ...(authStatus.userId ? { userId: authStatus.userId } : {}),
+            ...(authStatus.openId ? { openId: authStatus.openId } : {}),
+            ...(authStatus.expiresAt ? { expiresAt: authStatus.expiresAt } : {}),
+            ...(authStatus.refreshExpiresAt ? { refreshExpiresAt: authStatus.refreshExpiresAt } : {}),
+            detail: authStatus.authenticated
+                ? "Feishu auth token is ready for document upload and real @mentions."
+                : appCredentialConfigured
+                    ? "Feishu runtime auth is available for document upload and user lookup."
+                    : "Feishu webhook delivery can still work, but document upload and real @mentions are unavailable until Optimus signs in to Feishu.",
+            ...(authReady ? {} : { recommendation: "Run `optimus feishu auth login` to enable analysis docs and real @mentions." })
+        },
+        mentions: {
+            requiresOpenId: true,
+            ready: authReady,
+            detail: authReady
+                ? "Authenticated Feishu user lookup is ready for real @mentions."
+                : "Real @mentions require `optimus feishu auth login`.",
+            ...(authReady ? {} : { recommendation: "Run `optimus feishu auth login`." })
+        }
     };
 }
-async function buildFeishuDoctorStatus() {
-    const env = buildFeishuEnvStatus();
-    const authCommand = "feishu auth login";
-    const resolverCommand = "feishu user resolve <xiaomi_email>";
-    try {
-        const versionResult = await execFileAsync("feishu", ["--version"], { encoding: "utf8" });
-        const version = typeof versionResult.stdout === "string" ? versionResult.stdout.trim() : String(versionResult.stdout).trim();
-        try {
-            const authResult = await execFileAsync("feishu", ["auth", "status"], { encoding: "utf8" });
-            const authText = `${typeof authResult.stdout === "string" ? authResult.stdout : String(authResult.stdout)}\n${typeof authResult.stderr === "string" ? authResult.stderr : String(authResult.stderr)}`.trim();
-            return {
-                env,
-                cli: {
-                    installed: true,
-                    authenticated: true,
-                    authCommand,
-                    ...(version ? { version } : {}),
-                    detail: authText || "Feishu CLI authenticated."
-                },
-                mentions: {
-                    requiresOpenId: true,
-                    resolverCommand,
-                    ready: true,
-                    detail: "Real @mentions require open_id resolution. Auth is ready; if resolve still fails, check Feishu app scope contact:user.id:readonly.",
-                    recommendation: "If @mentions still degrade to text, verify the Feishu app has contact:user.id:readonly."
-                }
-            };
-        }
-        catch (error) {
-            const detail = extractCommandFailureDetail(error) || "Feishu CLI is installed but not authenticated.";
-            return {
-                env,
-                cli: {
-                    installed: true,
-                    authenticated: false,
-                    authCommand,
-                    ...(version ? { version } : {}),
-                    detail,
-                    recommendation: "Run 'feishu auth login' to refresh Feishu authorization for doc upload and user identity resolution."
-                },
-                mentions: {
-                    requiresOpenId: true,
-                    resolverCommand,
-                    ready: false,
-                    detail: "Real @mentions require open_id resolution, but Feishu CLI auth is not ready.",
-                    recommendation: "Run 'feishu auth login' before relying on Feishu user resolution or real @mentions."
-                }
-            };
-        }
-    }
-    catch (error) {
-        const detail = extractCommandFailureDetail(error) || "Feishu CLI is not installed.";
-        return {
-            env,
-            cli: {
-                installed: false,
-                authenticated: false,
-                authCommand,
-                detail,
-                recommendation: "Install Feishu CLI first, then run 'feishu auth login' if you need Feishu delivery, docs, or real @mentions."
-            },
-            mentions: {
-                requiresOpenId: true,
-                resolverCommand,
-                ready: false,
-                detail: "Real @mentions require Feishu CLI user resolution support.",
-                recommendation: "Install Feishu CLI and authenticate before relying on Feishu open_id resolution."
-            }
-        };
-    }
+function buildFeishuRuntimeStatus(config) {
+    const authStatus = new FeishuAuthService().readStatus();
+    return {
+        webhook: Boolean(config.delivery.feishu.webhook?.trim() || process.env.OPTIMUS_FEISHU_WEBHOOK?.trim()),
+        webhooks: Boolean(config.delivery.feishu.webhooks?.some((value) => value.trim()) || process.env.OPTIMUS_FEISHU_WEBHOOKS?.trim()),
+        secret: Boolean(config.delivery.feishu.secret?.trim() || process.env.OPTIMUS_FEISHU_SECRET?.trim()),
+        auth: authStatus.authenticated || Boolean((config.delivery.feishu.appId?.trim() || process.env.FEISHU_APP_ID?.trim()) && (config.delivery.feishu.appSecret?.trim() || process.env.FEISHU_APP_SECRET?.trim()))
+    };
 }
 function extractCommandFailureDetail(error) {
     if (!(error instanceof Error)) {
@@ -950,7 +953,7 @@ async function promptSetupAnswers(defaults) {
             const providerKeyLabel = codexProviderApiKeyEnvName || defaults.codexProviderApiKeyEnvName || "the configured provider env";
             codexApiKey = (await ask(renderSetupPrompt("Optional", `Provider API key value for ${providerKeyLabel}`, "leave blank to keep existing"))).trim() || undefined;
         }
-        printSetupSection("Feishu", "Enable this module when task notifications should be sent to Feishu.");
+        printSetupSection("Feishu", "Enable this module when task notifications should be sent to Feishu. Use `optimus feishu auth login` later for analysis docs and real @mentions.");
         const enableFeishuInput = (await ask(renderSetupPrompt("Optional module", "Enable Feishu delivery", defaults.enableFeishu ? "Y/n" : "y/N"))).trim().toLowerCase();
         const enableFeishu = enableFeishuInput.length === 0
             ? defaults.enableFeishu
@@ -1429,6 +1432,13 @@ async function runQuickDoctor(configPath = resolveDefaultConfigPath()) {
             impact: "Notifications will stay console-only."
         });
     }
+    else if (!new FeishuAuthService().readStatus().authenticated && (!config.delivery.feishu.appId?.trim() || !config.delivery.feishu.appSecret?.trim())) {
+        warnings.push({
+            code: "feishu_auth_missing",
+            message: "Feishu auth token is missing.",
+            impact: "Webhook messages can still be sent, but analysis document upload and real @mentions will be skipped."
+        });
+    }
     if (config.jira.enabled) {
         const jiraIssues = resolveJiraQuickDoctorIssues(config.jira, {
             sentryEnabled: config.sentry.enabled
@@ -1727,7 +1737,7 @@ async function main() {
                 : firstArg;
     const commandArgs = rest;
     if (command === "help") {
-        const requestedCommand = commandArgs[0]?.trim();
+        const requestedCommand = commandArgs.slice(0, 2).join(" ").trim() || commandArgs[0]?.trim();
         if (requestedCommand) {
             console.log(renderCommandHelp(requestedCommand) ?? renderCliHelp());
             process.exitCode = renderCommandHelp(requestedCommand) ? 0 : 1;
@@ -1814,6 +1824,60 @@ async function main() {
         process.exitCode = result.doctorQuick.summary === "blocked" ? 1 : 0;
         return;
     }
+    if (command === "feishu") {
+        const [firstSubcommand, secondSubcommand] = commandArgs;
+        const args = parseArgs(commandArgs.slice(2));
+        if (firstSubcommand !== "auth" || !secondSubcommand) {
+            console.log(renderCommandHelp("feishu") ?? renderCliHelp());
+            process.exitCode = 1;
+            return;
+        }
+        const authService = new FeishuAuthService();
+        if (secondSubcommand === "status") {
+            const status = authService.readStatus();
+            if (args.json === "true") {
+                console.log(JSON.stringify(status, null, 2));
+            }
+            else if (status.authenticated) {
+                console.log(`Feishu auth is ready. user=${status.userId ?? "unknown"} open_id=${status.openId ?? "unknown"} expires=${status.expiresAt ?? "unknown"}`);
+            }
+            else {
+                console.log("Feishu auth is not ready. Run `optimus feishu auth login`.");
+            }
+            process.exitCode = status.authenticated ? 0 : 1;
+            return;
+        }
+        if (secondSubcommand === "login") {
+            const result = await authService.login({
+                onPrompt: ({ verificationUrl, expiresInSeconds }) => {
+                    console.error(`Open this URL to authorize:\n${verificationUrl}\n`);
+                    console.error(`Waiting for authorization (expires in ${expiresInSeconds}s)...`);
+                }
+            });
+            if (args.json === "true") {
+                console.log(JSON.stringify({
+                    ok: true,
+                    userId: result.userId ?? null,
+                    openId: result.openId ?? null,
+                    verificationUrl: result.verificationUrl,
+                    expiresAt: new Date(result.expiresAtMs).toISOString(),
+                    refreshExpiresAt: new Date(result.refreshExpiresAtMs).toISOString()
+                }, null, 2));
+            }
+            else {
+                console.log(`Feishu auth succeeded. user=${result.userId ?? "unknown"} open_id=${result.openId ?? "unknown"}`);
+            }
+            return;
+        }
+        if (secondSubcommand === "logout") {
+            await authService.logout();
+            console.log("Feishu auth cleared.");
+            return;
+        }
+        console.log(renderCommandHelp("feishu") ?? renderCliHelp());
+        process.exitCode = 1;
+        return;
+    }
     if (mapJiraCommand(command)) {
         process.exitCode = await forwardJiraCliCommand(command, commandArgs);
         return;
@@ -1978,7 +2042,7 @@ async function main() {
             : [];
         const reviewAwareNotifier = new FeishuNotifier({ config, publicationAttempts, format: config.delivery.feishu.format });
         const message = reviewAwareNotifier.previewMessage(bundle);
-        const envStatus = buildFeishuEnvStatus();
+        const envStatus = buildFeishuRuntimeStatus(config);
         if (args["print-env-status"] === "true") {
             console.log(JSON.stringify({ envStatus }, null, 2));
             process.exitCode = envStatus.webhook || envStatus.webhooks ? 0 : 1;
@@ -2018,7 +2082,7 @@ async function main() {
         const publicationAttempts = await store.listTaskPublicationAttempts(taskId);
         const notifier = new FeishuNotifier({ config, publicationAttempts, format: config.delivery.feishu.format });
         const message = notifier.previewMessage(bundle);
-        const envStatus = buildFeishuEnvStatus();
+        const envStatus = buildFeishuRuntimeStatus(config);
         if (args["print-env-status"] === "true") {
             console.log(JSON.stringify({ taskId, channel, envStatus }, null, 2));
             process.exitCode = envStatus.webhook || envStatus.webhooks ? 0 : 1;
@@ -2073,7 +2137,7 @@ async function main() {
             deliveryBundle: existingBundle
         });
         const deliveryService = new TaskDeliveryService();
-        const analysisDocService = new FeishuAnalysisDocService({ refStore: store });
+        const analysisDocService = new FeishuAnalysisDocService({ config, refStore: store });
         const publicationService = new TaskPublicationService(logger);
         const deliveryDispatcher = new TaskDeliveryDispatcher(config);
         let deliveryBundle = mergeReplayBundle(await deliveryService.buildBundle({
@@ -2708,7 +2772,7 @@ async function main() {
         const skillSyncStatus = await logger.readSkillSyncSnapshot();
         const evolutionStatus = await logger.readEvolutionSnapshot();
         const repoMemoryStatus = await logger.readRepoMemorySnapshot();
-        const feishuStatus = await buildFeishuDoctorStatus();
+        const feishuStatus = await buildFeishuDoctorStatus(config);
         const preflight = await new CodexPreflight(config).run();
         const skillSummary = await inspectBuiltinSkills(config, skillSyncService);
         const repoMemorySummary = await new RepoMemoryService(config).readDoctorSummary();
@@ -3086,7 +3150,7 @@ function resolveTimeoutKind(run, config, waitingForFirstSignal, elapsedMs, idleM
     if (elapsedMs >= config.runtime.runTimeoutMs) {
         return "hard_timeout";
     }
-    if (waitingForFirstSignal && elapsedMs >= config.runtime.startupTimeoutMs) {
+    if (waitingForFirstSignal && idleMs >= config.runtime.startupTimeoutMs) {
         return "startup_timeout";
     }
     if (!waitingForFirstSignal && idleMs >= config.runtime.idleTimeoutMs) {