@opendatalabs/connect 0.10.0 → 0.10.1-canary.2898948

package/dist/cli/index.js

@@ -26,14 +26,15 @@ const vanaPromptTheme = {
         },
     },
 };
-import { createConnectRenderer, createHumanRenderer, formatDisplayPath, formatRelativeTime, } from "./render/index.js";
+import { createConnectRenderer, createHumanRenderer, createLoginRenderer, formatDisplayPath, formatRelativeTime, } from "./render/index.js";
 import { CliOutcomeStatus, migrateLegacyDataHome, getBrowserProfilesDir, getConnectorCacheDir, getLogsDir, getSessionsDir, getSourceResultPath, readCliState, readCliConfig, updateCliConfig, updateSourceState, } from "../core/index.js";
 import { fetchConnectorToCache, listAvailableSources, readCachedConnectorMetadata, } from "../connectors/registry.js";
-import { detectPersonalServerTarget, ingestResult, } from "../personal-server/index.js";
+import { detectPersonalServerTarget, ingestResult, resolvePersonalServerAuthConfig, } from "../personal-server/index.js";
 import { findDataConnectorsDir, ManagedPlaywrightRuntime, } from "../runtime/index.js";
 import { listAvailableSkills, installSkill, readInstalledSkills, } from "../skills/index.js";
 import { queryStatus, querySources, queryDataList, queryDataShow, queryDoctor, } from "./queries.js";
 import { checkForUpdate, readUpdateCheck, isNewerVersion, } from "./update-check.js";
+import { loadCredentials, saveCredentials, clearCredentials, isExpired, formatAddress, formatExpiresIn, getAuthTarget, resolvePersonalServerUrl, runDeviceCodeFlow, runSelfHostedLoginFlow, } from "./auth.js";
 function cleanDescription(desc) {
     return desc
         .replace(/ using Playwright browser automation\.?/i, ".")
@@ -73,6 +74,7 @@ export async function runCli(argv = process.argv) {
         .showSuggestionAfterError(true)
         .addHelpText("after", `
 Quick start:
+  vana login             Log in to your Vana account
   vana connect           Connect a source and collect data
   vana sources           Browse available sources
   vana status            Check system health
@@ -330,6 +332,19 @@ Examples:
         .action(async (scope) => {
         process.exitCode = await runServerData(scope, parsedOptions);
     });
+    program
+        .command("login")
+        .description("Log in to your Vana account or a self-hosted Personal Server")
+        .option("-s, --server <url>", "Self-hosted Personal Server URL")
+        .action(async (loginOptions) => {
+        process.exitCode = await runLogin(parsedOptions, loginOptions.server);
+    });
+    program
+        .command("logout")
+        .description("Log out and remove saved credentials")
+        .action(async () => {
+        process.exitCode = await runLogout(parsedOptions);
+    });
     program
         .command("mcp")
         .description("Start MCP server for agent integration")
@@ -1151,10 +1166,18 @@ async function runStatus(options) {
         }
     }
     if (options.json) {
+        const jsonAuthCreds = loadCredentials();
         const compactJson = {
             runtime: status.runtime,
             personalServer: status.personalServer,
             personalServerUrl: status.personalServerUrl,
+            auth: jsonAuthCreds
+                ? {
+                    authenticated: !isExpired(jsonAuthCreds),
+                    address: jsonAuthCreds.account.address,
+                    expires_at: jsonAuthCreds.account.expires_at,
+                }
+                : { authenticated: false },
             sources: {
                 connected: status.summary?.connectedCount ?? 0,
                 needsAttention: status.summary?.needsAttentionCount ?? 0,
@@ -1177,6 +1200,16 @@ async function runStatus(options) {
     else {
         emit.keyValue("Personal Server", "not connected", "warning");
     }
+    // Auth state
+    const authCreds = loadCredentials();
+    if (authCreds && !isExpired(authCreds)) {
+        emit.keyValue("Account", formatAddress(authCreds.account.address), "success");
+        emit.keyValue("Auth", `Authenticated (expires in ${formatExpiresIn(authCreds.account.expires_at)})`, "success");
+    }
+    else {
+        emit.keyValue("Account", "Not logged in", "muted");
+        emit.keyValue("Auth", "Run `vana login` to authenticate", "muted");
+    }
     const connectedCount = status.summary?.connectedCount ?? 0;
     const attentionCount = status.summary?.needsAttentionCount ?? 0;
     const sourceParts = [
@@ -1204,8 +1237,18 @@ async function runStatus(options) {
             const displayName = displaySource(sourceId, sourceLabels);
             const sourceStatus = status.sources.find((s) => s.source === sourceId);
             const sourceOverdue = sourceStatus?.isOverdue ?? false;
-            const healthTone = sourceOverdue ? "warning" : toneForHealth(health);
-            const healthLabel = health === "needs_reauth" ? "needs login" : health;
+            const dataState = stored?.dataState;
+            // Show worst of connectionHealth and dataState
+            let healthLabel;
+            let healthTone;
+            if (dataState === "ingest_failed") {
+                healthLabel = "sync failed";
+                healthTone = "warning";
+            }
+            else {
+                healthTone = sourceOverdue ? "warning" : toneForHealth(health);
+                healthLabel = health === "needs_reauth" ? "needs login" : health;
+            }
             const staleTag = sourceOverdue
                 ? ` ${emit.badge("stale", "warning")}`
                 : "";
@@ -1213,7 +1256,11 @@ async function runStatus(options) {
                 ? `collected ${formatRelativeTime(stored.lastCollectedAt)}`
                 : "";
             emit.keyValue(`  ${displayName}`, `${healthLabel}${staleTag}     ${collectedAgo}`, healthTone);
-            if ((health === "needs_reauth" || health === "error") &&
+            if (dataState === "ingest_failed") {
+                const errMsg = stored?.lastError ?? "sync failed";
+                emit.detail(`  \u21b3 ${errMsg}. Run \`vana connect ${sourceId}\``);
+            }
+            else if ((health === "needs_reauth" || health === "error") &&
                 stored?.connectionHealthReason) {
                 const msg = formatHealthMessage(stored.connectionHealthReason);
                 const ago = stored.connectionHealthChangedAt
@@ -1233,6 +1280,47 @@ async function runStatus(options) {
             return 0;
         }
     }
+    // Show attention-needing sources that weren't already displayed above
+    const displayedSourceIds = new Set(connectedSources.map(([id]) => id));
+    const hiddenAttentionSources = status.sources.filter((s) => rankSourceStatus(s) <= 4 && !displayedSourceIds.has(s.source));
+    if (hiddenAttentionSources.length > 0) {
+        if (connectedSources.length === 0) {
+            emit.blank();
+        }
+        for (const source of hiddenAttentionSources) {
+            const displayName = displaySource(source.source, sourceLabels);
+            const presentation = getSourceStatusPresentation(source);
+            const collectedAgo = source.lastCollectedAt
+                ? `collected ${formatRelativeTime(source.lastCollectedAt)}`
+                : "";
+            emit.keyValue(`  ${displayName}`, `${presentation.label}${collectedAgo ? `     ${collectedAgo}` : ""}`, presentation.tone);
+            // Show actionable detail line
+            if (source.lastRunOutcome === CliOutcomeStatus.INGEST_FAILED &&
+                source.ingestScopes) {
+                const failedScopes = source.ingestScopes.filter((s) => s.status === "failed");
+                for (const scope of failedScopes) {
+                    const errMsg = scope.error ?? "sync failed";
+                    emit.detail(`  \u21b3 ${source.source}.${scope.scope}: ${errMsg}. Run \`vana connect ${source.source}\``);
+                }
+                if (failedScopes.length === 0) {
+                    emit.detail(`  \u21b3 Sync failed. Run \`vana connect ${source.source}\``);
+                }
+            }
+            else if (source.lastRunOutcome === CliOutcomeStatus.CONNECTOR_UNAVAILABLE) {
+                emit.detail(`  \u21b3 No connector available. Run \`vana sources\``);
+            }
+            else if (source.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
+                const reason = source.lastError ?? "runtime error";
+                emit.detail(`  \u21b3 ${reason}. Run \`vana connect ${source.source}\``);
+            }
+            else if (source.lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT) {
+                emit.detail(`  \u21b3 Requires interactive login. Run \`vana connect ${source.source}\``);
+            }
+            else if (source.lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
+                emit.detail(`  \u21b3 Manual auth step required. Run \`vana connect ${source.source}\``);
+            }
+        }
+    }
     if (nextSteps.length > 0) {
         emit.blank();
         const command = extractCommand(nextSteps[0]);
@@ -1353,9 +1441,11 @@ async function runServerStatus(options) {
             ? "(auto-detected)"
             : target.source === "config"
                 ? "(saved)"
-                : target.source === "env"
-                    ? "(from VANA_PERSONAL_SERVER_URL)"
-                    : `(${target.source ?? "unknown"})`;
+                : target.source === "auth"
+                    ? "(from vana login)"
+                    : target.source === "env"
+                        ? "(from VANA_PERSONAL_SERVER_URL)"
+                        : `(${target.source ?? "unknown"})`;
         emit.keyValue("URL", `${target.url} ${urlSuffix}`, "muted");
     }
     const stateLabel = target.state === "available" ? "healthy" : "Not connected";
@@ -2074,12 +2164,20 @@ async function runServerData(scope, options) {
     }
     // If PS is available, try to list remote scopes via client
     let remoteScopes = [];
+    let didQueryRemoteScopes = false;
     let remoteScopeFallbackReason;
     if (target.state === "available" && target.url) {
+        const auth = resolvePersonalServerAuthConfig(target.url);
         try {
-            const { createPersonalServerClient: createClient } = await import("../personal-server/client.js");
-            const client = createClient({ url: target.url });
-            remoteScopes = await client.listScopes(scope);
+            if (auth?.type === "bearerToken") {
+                const { createPersonalServerClient: createClient } = await import("../personal-server/client.js");
+                const client = createClient({
+                    url: target.url,
+                    auth,
+                });
+                didQueryRemoteScopes = true;
+                remoteScopes = await client.listScopes(scope);
+            }
         }
         catch (err) {
             remoteScopeFallbackReason =
@@ -2087,7 +2185,7 @@ async function runServerData(scope, options) {
         }
     }
     // Use remote scopes if available, otherwise fall back to local
-    const scopeList = remoteScopes.length > 0
+    const scopeList = didQueryRemoteScopes
         ? remoteScopes.map((s) => ({
             scope: s.scope,
             detail: `${s.count} version${s.count !== 1 ? "s" : ""}`,
@@ -2100,13 +2198,15 @@ async function runServerData(scope, options) {
         process.stdout.write(`${JSON.stringify({
             count: scopeList.length,
             scopes: scopeList,
-            source: remoteScopes.length > 0 ? "remote" : "local",
+            source: didQueryRemoteScopes ? "remote" : "local",
             ...(remoteScopeFallbackReason ? { remoteScopeFallbackReason } : {}),
         })}\n`);
         return 0;
     }
     if (scopeList.length === 0) {
-        emit.info("No scopes found.");
+        emit.info(didQueryRemoteScopes
+            ? "No data on your Personal Server."
+            : "No scopes found.");
         if (target.state !== "available") {
             emit.detail("Personal Server is not available. Showing locally-known scopes only.");
         }
@@ -2115,7 +2215,7 @@ async function runServerData(scope, options) {
     for (const entry of scopeList) {
         emit.keyValue(entry.scope, entry.detail, "muted");
     }
-    if (remoteScopes.length === 0 && localScopes.length > 0) {
+    if (!didQueryRemoteScopes && localScopes.length > 0) {
         emit.blank();
         emit.detail("Showing locally-known scopes. Connect your Personal Server for live data.");
     }
@@ -2872,6 +2972,11 @@ export function getSourceStatusPresentation(source) {
     if (!source.installed && !source.lastRunOutcome) {
         return { label: "not connected", tone: "muted" };
     }
+    // Check dataState before early-returning on missing lastRunOutcome —
+    // ingest can fail even when lastRunOutcome is unset
+    if (source.dataState === "ingest_failed") {
+        return { label: "sync failed", tone: "error" };
+    }
     if (!source.lastRunOutcome) {
         return { label: "installed", tone: "success" };
     }
@@ -2904,9 +3009,6 @@ export function getSourceStatusPresentation(source) {
     if (source.dataState === "collected_local") {
         return { label: "local", tone: "muted" };
     }
-    if (source.dataState === "ingest_failed") {
-        return { label: "sync failed", tone: "error" };
-    }
     return { label: "connected", tone: "success" };
 }
 export function toneForRuntime(runtime) {
@@ -3009,6 +3111,9 @@ export function rankSourceStatus(source) {
     if (source.lastRunOutcome === CliOutcomeStatus.CONNECTOR_UNAVAILABLE) {
         return 4;
     }
+    if (source.dataState === "ingest_failed") {
+        return 2;
+    }
     if (source.dataState === "ingested_personal_server") {
         return 5;
     }
@@ -3899,4 +4004,195 @@ async function runSkillShow(name, options) {
         return 1;
     }
 }
+// ── Login / Logout ─────────────────────────────────────────────────────
+async function runLogin(options, serverUrl) {
+    // Determine auth target: cloud (account.vana.org) or self-hosted (PS directly)
+    const psUrl = serverUrl ?? resolvePersonalServerUrl() ?? null;
+    const authTarget = getAuthTarget(psUrl);
+    // If self-hosted, use /auth/device flow against the PS
+    if (authTarget === "self-hosted" && psUrl) {
+        const renderer = !options.json && !options.quiet ? createLoginRenderer() : null;
+        renderer?.title(psUrl);
+        try {
+            const result = await runSelfHostedLoginFlow(psUrl, (url) => {
+                renderer?.note("Open this URL in your browser:");
+                renderer?.note(url);
+                renderer?.scopeActive("Waiting for authorization");
+                // Try to open browser — use spawn with args array to prevent shell injection
+                // (a malicious self-hosted PS could return a URL with shell metacharacters)
+                try {
+                    const { spawn } = require("node:child_process");
+                    const opener = process.platform === "darwin"
+                        ? "open"
+                        : process.platform === "win32"
+                            ? "start"
+                            : "xdg-open";
+                    spawn(opener, [url], { detached: true, stdio: "ignore" }).unref();
+                }
+                catch {
+                    // Browser open failed — user will open manually
+                }
+            });
+            await saveCredentials({
+                account: {
+                    address: result.address,
+                    session_token: "",
+                    expires_at: result.expires_at,
+                },
+                personal_server: {
+                    url: psUrl,
+                    session_token: result.session_token,
+                    expires_at: result.expires_at,
+                },
+            });
+            await updateCliConfig({ personalServerUrl: psUrl });
+            renderer?.success(`Logged in to ${psUrl}`);
+            renderer?.detail("Credentials saved to ~/.vana/auth.json");
+            return 0;
+        }
+        catch (err) {
+            renderer?.fail("Login failed");
+            renderer?.detail(err instanceof Error ? err.message : String(err));
+            renderer?.next(`vana login --server ${psUrl}`);
+            return 1;
+        }
+        finally {
+            renderer?.cleanup();
+        }
+    }
+    // Cloud flow (account.vana.org)
+    // Check env var shortcut
+    const envToken = process.env.VANA_SESSION_TOKEN;
+    if (envToken) {
+        const creds = loadCredentials();
+        if (creds) {
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({ status: "authenticated", source: "env", address: creds.account.address })}\n`);
+            }
+            else {
+                const emit = createEmitter(options);
+                emit.success(`Already authenticated via VANA_SESSION_TOKEN env var`);
+            }
+            return 0;
+        }
+    }
+    // Check if already logged in
+    const existing = loadCredentials();
+    if (existing && !isExpired(existing)) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({
+                status: "authenticated",
+                address: existing.account.address,
+                personal_server: existing.personal_server?.url ?? null,
+                expires_at: existing.account.expires_at,
+            })}\n`);
+        }
+        else {
+            const emit = createEmitter(options);
+            emit.success(`Already logged in as ${formatAddress(existing.account.address)}`);
+            if (existing.personal_server) {
+                emit.keyValue("Personal Server", existing.personal_server.url, "success");
+            }
+            emit.info(`  Auth expires in ${formatExpiresIn(existing.account.expires_at)}`);
+            emit.blank();
+            emit.info("  Run `vana logout` first to re-authenticate.");
+        }
+        return 0;
+    }
+    if (options.json) {
+        // JSON mode: run flow and output result
+        const creds = await runDeviceCodeFlow({
+            onCode: (code, uri) => {
+                process.stderr.write(JSON.stringify({ event: "device_code", code, uri }) + "\n");
+            },
+            onWaiting: () => { },
+            onAuthorized: () => { },
+            onExpired: () => {
+                process.stdout.write(JSON.stringify({ status: "expired", error: "Device code expired" }) +
+                    "\n");
+            },
+            onError: (err) => {
+                process.stdout.write(JSON.stringify({ status: "error", error: err.message }) + "\n");
+            },
+        });
+        if (creds) {
+            await saveCredentials(creds);
+            if (creds.personal_server?.url) {
+                await updateCliConfig({ personalServerUrl: creds.personal_server.url });
+            }
+            process.stdout.write(`${JSON.stringify({
+                status: "authenticated",
+                address: creds.account.address,
+                personal_server: creds.personal_server?.url ?? null,
+                expires_at: creds.account.expires_at,
+            })}\n`);
+            return 0;
+        }
+        return 1;
+    }
+    // Interactive mode
+    const renderer = createLoginRenderer();
+    renderer.title("Vana");
+    const creds = await runDeviceCodeFlow({
+        onCode: (code, uri) => {
+            renderer.note("Open this URL in your browser:");
+            renderer.note(uri);
+            renderer.note(`Enter this code: ${code}`);
+        },
+        onWaiting: () => {
+            renderer.scopeActive("Waiting for authorization");
+        },
+        onAuthorized: async (authedCreds) => {
+            await saveCredentials(authedCreds);
+            if (authedCreds.personal_server?.url) {
+                await updateCliConfig({
+                    personalServerUrl: authedCreds.personal_server.url,
+                });
+            }
+            renderer.success(`Logged in as ${formatAddress(authedCreds.account.address)}`);
+            if (authedCreds.personal_server) {
+                renderer.detail(`Personal Server: ${authedCreds.personal_server.url}`);
+            }
+            renderer.detail("Credentials saved to ~/.vana/auth.json");
+        },
+        onExpired: () => {
+            renderer.fail("Authorization expired");
+            renderer.next("vana login");
+        },
+        onError: (err) => {
+            renderer.fail("Login failed");
+            renderer.detail(err.message);
+            renderer.next("vana login");
+        },
+    });
+    renderer.cleanup();
+    return creds ? 0 : 1;
+}
+async function runLogout(options) {
+    // Revoke the token server-side before clearing local credentials
+    const creds = loadCredentials();
+    if (creds?.personal_server?.url && creds.personal_server.session_token) {
+        try {
+            await fetch(`${creds.personal_server.url.replace(/\/$/, "")}/auth/device/token`, {
+                method: "DELETE",
+                headers: {
+                    Authorization: `Bearer ${creds.personal_server.session_token}`,
+                },
+                signal: AbortSignal.timeout(5000),
+            });
+        }
+        catch {
+            // Best-effort — server may be down, but we still clear local creds
+        }
+    }
+    await clearCredentials();
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ status: "logged_out" })}\n`);
+    }
+    else {
+        const emit = createEmitter(options);
+        emit.success("Logged out. Credentials removed.");
+    }
+    return 0;
+}
 //# sourceMappingURL=index.js.map