@opendatalabs/connect 0.8.1-canary.ac15bfe → 0.8.1-canary.d23fbf5

package/README.md

@@ -78,28 +78,84 @@ If you prefer to integrate the SDK into an existing project, follow the steps be
 
 ### Install
 
-Use the published package directly:
+If you are evaluating this branch before it lands on `main`, use the prerelease path in the next section. The stable install commands below are the intended post-merge install path.
+
+macOS with Homebrew:
 
 ```bash
-pnpm dlx @opendatalabs/connect status
+brew tap vana-com/vana
+brew install vana
 ```
 
-Or install it globally:
+macOS and Linux:
 
 ```bash
-pnpm add -g @opendatalabs/connect
-vana status
+curl -fsSL https://raw.githubusercontent.com/vana-com/vana-connect/main/install/install.sh | sh
+```
+
+Windows PowerShell:
+
+```powershell
+iwr https://raw.githubusercontent.com/vana-com/vana-connect/main/install/install.ps1 -useb | iex
+```
+
+Both installers fetch the latest GitHub release asset for your platform, verify its checksum, and install `vana` without requiring Node or npm.
+
+### Canary / prerelease testing
+
+If you are testing an unreleased branch build, install from the branch installer and pass the prerelease tag explicitly.
+
+macOS with Homebrew:
+
+```bash
+brew tap vana-com/vana
+brew install vana
+```
+
+The current Homebrew tap is following the latest `vana-connect` canary while this CLI is still rolling out.
+
+macOS and Linux:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/vana-com/vana-connect/feat/connect-cli-v1/install/install.sh | sh -s -- --version canary-feat-connect-cli-v1
+```
+
+Windows PowerShell:
+
+```powershell
+& ([scriptblock]::Create((iwr https://raw.githubusercontent.com/vana-com/vana-connect/feat/connect-cli-v1/install/install.ps1 -useb).Content)) --version canary-feat-connect-cli-v1
+```
+
+The current hosted prerelease is:
+
+`canary-feat-connect-cli-v1`
+
+Release page:
+
+`https://github.com/vana-com/vana-connect/releases/tag/canary-feat-connect-cli-v1`
+
+If you want the npm package path as a fallback:
+
+```bash
+npx -y @opendatalabs/connect status
 ```
 
 ### Commands
 
 ```bash
+vana connect
 vana sources
 vana connect github
 vana status
 vana setup
+vana data list
+vana data show github --json | jq
 ```
 
+- `vana connect` opens a guided source picker in human mode.
+- `vana connect <source>` runs the end-to-end collection flow.
+- `vana data ...` lets you inspect collected local datasets without opening the raw JSON file yourself.
+
 ### Local development
 
 From this repo:
@@ -111,6 +167,18 @@ node dist/cli/bin.js status
 ```
 
 The CLI installs its local browser runtime under `~/.dataconnect/`.
+That runtime is bundled from `vana-connect` itself, so `vana setup` does not require a separate `data-connect` checkout.
+
+To build a standalone launcher plus app payload locally:
+
+```bash
+pnpm build
+pnpm build:sea
+./artifacts/sea/vana-linux-x64/vana status --json
+```
+
+`pnpm build:sea` uses Node 25's `--build-sea` flow to create a small `vana` launcher and packages the real app payload next to it under `app/`.
+It produces a platform-specific release directory plus a release archive and matching checksum file under `artifacts/sea/`.
 
 ### Programmatic runtime access
 

package/dist/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAkDA,wBAAsB,MAAM,CAAC,IAAI,WAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CA2CjE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAuEA,wBAAsB,MAAM,CAAC,IAAI,WAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAsEjE"}

package/dist/cli/index.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
-import { confirm, input, password } from "@inquirer/prompts";
+import { confirm, input, password, select } from "@inquirer/prompts";
 import { Command } from "commander";
+import { createHumanRenderer } from "./render/index.js";
 import { CliOutcomeStatus, getBrowserProfilesDir, getConnectorCacheDir, getLastResultPath, readCliState, updateSourceState, } from "../core/index.js";
 import { listAvailableSources } from "../connectors/registry.js";
 import { detectPersonalServerTarget, ingestResult, } from "../personal-server/index.js";
@@ -13,13 +14,15 @@ export async function runCli(argv = process.argv) {
     const program = new Command();
     program.name("vana").description("Vana Connect CLI");
     program
-        .command("connect <source>")
+        .command("connect [source]")
         .option("--json", "Output machine-readable JSON")
         .option("--no-input", "Fail instead of prompting for input")
         .option("--yes", "Approve safe setup prompts automatically")
         .option("--quiet", "Reduce non-essential output")
         .action(async (source) => {
-        process.exitCode = await runConnect(source, parsedOptions);
+        process.exitCode = source
+            ? await runConnect(source, parsedOptions)
+            : await runConnectEntry(parsedOptions);
     });
     program
         .command("sources")
@@ -43,6 +46,27 @@ export async function runCli(argv = process.argv) {
         .action(async () => {
         process.exitCode = await runSetup(parsedOptions);
     });
+    const data = program.command("data").description("Inspect collected data");
+    data
+        .command("list")
+        .description("List locally available collected datasets")
+        .option("--json", "Output machine-readable JSON")
+        .action(async () => {
+        process.exitCode = await runDataList(parsedOptions);
+    });
+    data
+        .command("show <source>")
+        .description("Show a collected dataset")
+        .option("--json", "Output machine-readable JSON")
+        .action(async (source) => {
+        process.exitCode = await runDataShow(source, parsedOptions);
+    });
+    data
+        .command("path <source>")
+        .description("Print the local path for a collected dataset")
+        .action(async (source) => {
+        process.exitCode = await runDataPath(source, parsedOptions);
+    });
     await program.parseAsync(normalizedArgv);
     return Number(process.exitCode ?? 0);
 }
@@ -61,7 +85,7 @@ async function runConnect(source, options) {
             emit.info(`Vana Connect needs a local browser runtime before it can connect ${displaySource(source, sourceLabels)}.`);
             emit.info("");
             emit.info("This will install:");
-            emit.info("- the connector runner");
+            emit.info("- the local browser runtime");
             emit.info("- a Chromium browser engine");
             emit.info("- local runtime files under ~/.dataconnect/");
             emit.info("");
@@ -199,16 +223,26 @@ async function runConnect(source, options) {
                 }
                 return 1;
             }
+            if (event.type === "headed-required") {
+                if (event.message) {
+                    emit.info(event.message);
+                }
+                if (event.url) {
+                    emit.info(`Opening ${displaySource(source, sourceLabels)} in a local browser session...`);
+                }
+                continue;
+            }
             if (event.type === "legacy-auth") {
                 await updateSourceState(resolution.source, {
                     lastRunAt: new Date().toISOString(),
                     lastRunOutcome: CliOutcomeStatus.LEGACY_AUTH,
                     lastError: event.message ?? "Legacy authentication is required.",
                     dataState: "none",
+                    lastResultPath: null,
                 });
                 emit.info(event.message ??
-                    "This connector requires legacy headed authentication that is not available in batch mode.");
-                emit.info(`Next: establish a reusable ${displaySource(source, sourceLabels)} session manually, or migrate this connector to requestInput.`);
+                    "This connector needs a manual browser step that is not available in non-interactive mode.");
+                emit.info(`Next: run \`vana connect ${source}\` without \`--no-input\`.`);
                 if (event.logPath) {
                     emit.info(`Run log: ${event.logPath}`);
                 }
@@ -240,6 +274,7 @@ async function runConnect(source, options) {
                 lastRunOutcome: CliOutcomeStatus.UNEXPECTED_INTERNAL_ERROR,
                 dataState: "none",
                 lastError: "Connector run ended without a result.",
+                lastResultPath: null,
             });
             emit.event({
                 type: "outcome",
@@ -262,7 +297,9 @@ async function runConnect(source, options) {
             lastRunOutcome: finalStatus,
             dataState,
             lastError: null,
+            lastResultPath: resultPath,
         });
+        const resultSummary = await readResultSummary(resultPath);
         if (finalStatus === CliOutcomeStatus.CONNECTED_AND_INGESTED) {
             emit.info(`Connected ${displaySource(source, sourceLabels)}.`);
             emit.info(`Collected your ${displaySource(source, sourceLabels)} data and synced it to your Personal Server.`);
@@ -275,6 +312,13 @@ async function runConnect(source, options) {
             emit.info(`Collected your ${displaySource(source, sourceLabels)} data and saved it locally.`);
             emit.info(`Local result: ${resultPath}`);
         }
+        if (resultSummary) {
+            emit.info("");
+            emit.info("Collected:");
+            for (const line of resultSummary.lines) {
+                emit.info(`- ${line}`);
+            }
+        }
         if (runLogPath) {
             emit.info(`Run log: ${runLogPath}`);
         }
@@ -314,6 +358,41 @@ async function runConnect(source, options) {
         return 1;
     }
 }
+async function runConnectEntry(options) {
+    const emit = createEmitter(options);
+    const sources = await loadRegistrySources();
+    if (options.json || options.noInput) {
+        emit.info("Specify a source. Run `vana sources` to see available options.");
+        return 1;
+    }
+    if (sources.length === 0) {
+        emit.info("No sources are available right now.");
+        emit.info("Run `vana sources` to verify the local connector registry.");
+        return 1;
+    }
+    emit.title("Connect data");
+    emit.blank();
+    emit.info("Choose a source to connect:");
+    let source;
+    try {
+        source = await select({
+            message: "Source",
+            choices: sources.map((item) => ({
+                name: `${item.name}${formatAuthModeBadge(item.authMode, emit)}${item.description ? ` - ${item.description}` : ""}`,
+                value: item.id,
+            })),
+        });
+    }
+    catch (error) {
+        if (isPromptCancelled(error)) {
+            emit.info("Cancelled.");
+            return 1;
+        }
+        throw error;
+    }
+    emit.blank();
+    return runConnect(source, options);
+}
 async function runList(options) {
     const sources = await loadRegistrySources();
     const installedSourceIds = new Set((await listInstalledConnectorFiles()).map((source) => source.source));
@@ -326,10 +405,23 @@ async function runList(options) {
         return 0;
     }
     const emit = createEmitter(options);
+    emit.title("Available sources");
+    emit.blank();
     for (const source of enrichedSources) {
-        const description = source.description ? ` - ${source.description}` : "";
-        const installed = source.installed ? " [installed]" : "";
-        emit.info(`${source.name}${installed}${description}`);
+        const badges = [];
+        if (source.installed) {
+            badges.push({ text: "installed", tone: "success" });
+        }
+        if (source.authMode === "interactive") {
+            badges.push({ text: "interactive", tone: "info" });
+        }
+        else if (source.authMode === "legacy") {
+            badges.push({ text: "legacy", tone: "warning" });
+        }
+        emit.sourceTitle(source.name, badges);
+        if (source.description) {
+            emit.detail(source.description);
+        }
     }
     return 0;
 }
@@ -344,7 +436,7 @@ async function runStatus(options) {
     const sources = await gatherSourceStatuses(state.sources, sourceMetadata);
     const status = {
         runtime: runtime.state,
-        runtimePath: runtime.state === "installed" ? runtime.runnerDir : null,
+        runtimePath: runtime.runtimePath,
         personalServer: personalServer.state,
         personalServerUrl: personalServer.url,
         sources,
@@ -353,16 +445,20 @@ async function runStatus(options) {
         process.stdout.write(`${JSON.stringify(status)}\n`);
         return 0;
     }
-    emit.info("Vana Connect status");
-    emit.info("");
-    emit.info(`Runtime: ${status.runtime}`);
-    emit.info(`Personal Server: ${status.personalServer}`);
-    emit.info("");
+    emit.title("Vana Connect status");
+    emit.blank();
+    emit.section("Environment");
+    emit.keyValue("Runtime", status.runtime, toneForRuntime(status.runtime));
+    emit.keyValue("Personal Server", status.personalServer, status.personalServer === "available" ? "success" : "muted");
+    if (status.sources.length > 0) {
+        emit.blank();
+        emit.section("Sources");
+    }
     for (const source of status.sources) {
-        emit.info(formatSourceStatus(source, sourceLabels));
+        emit.info(formatSourceStatus(source, sourceLabels, emit));
         const details = formatSourceStatusDetail(source);
         if (details) {
-            emit.info(`  ${details}`);
+            emit.detail(details);
         }
     }
     return 0;
@@ -401,7 +497,101 @@ async function runSetup(options) {
         return 1;
     }
 }
+async function runDataList(options) {
+    const state = await readCliState();
+    const sources = await gatherSourceStatuses(state.sources, createSourceMetadataMap(await loadRegistrySources()));
+    const datasets = sources
+        .filter((source) => Boolean(source.lastResultPath))
+        .map((source) => ({
+        source: source.source,
+        name: source.name,
+        dataState: source.dataState,
+        lastRunAt: source.lastRunAt ?? null,
+        path: source.lastResultPath ?? null,
+    }));
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ datasets })}\n`);
+        return 0;
+    }
+    const emit = createEmitter(options);
+    if (datasets.length === 0) {
+        emit.info("No local datasets collected yet.");
+        emit.info("Run `vana connect <source>` to collect data.");
+        return 0;
+    }
+    emit.title("Collected data");
+    emit.blank();
+    for (const dataset of datasets) {
+        const badges = dataset.dataState === "ingested_personal_server"
+            ? [{ text: "synced", tone: "success" }]
+            : [{ text: "local", tone: "muted" }];
+        emit.sourceTitle(dataset.name ?? displaySource(dataset.source), badges);
+        emit.detail(dataset.path ?? "");
+    }
+    return 0;
+}
+async function runDataShow(source, options) {
+    const sourceLabels = createSourceLabelMap(await loadRegistrySources());
+    const state = await readCliState();
+    const record = state.sources[source];
+    const resultPath = record?.lastResultPath;
+    const emit = createEmitter(options);
+    if (!resultPath) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({
+                error: "dataset_not_found",
+                source,
+                message: `No collected dataset found for ${displaySource(source, sourceLabels)}. Run \`vana connect ${source}\` first.`,
+            })}\n`);
+        }
+        else {
+            emit.info(`No collected dataset found for ${displaySource(source, sourceLabels)}. Run \`vana connect ${source}\` first.`);
+        }
+        return 1;
+    }
+    try {
+        const raw = await fsp.readFile(resultPath, "utf8");
+        const data = JSON.parse(raw);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ source, path: resultPath, data })}\n`);
+            return 0;
+        }
+        const summary = summarizeResultData(data);
+        emit.title(`${displaySource(source, sourceLabels)} data`);
+        emit.blank();
+        if (summary) {
+            for (const line of summary.lines) {
+                emit.bullet(line);
+            }
+            emit.blank();
+        }
+        emit.keyValue("Path", resultPath, "muted");
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : `Could not read ${resultPath}.`;
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ error: "dataset_read_failed", source, path: resultPath, message })}\n`);
+        }
+        else {
+            emit.info(message);
+        }
+        return 1;
+    }
+}
+async function runDataPath(source, options) {
+    const sourceLabels = createSourceLabelMap(await loadRegistrySources());
+    const state = await readCliState();
+    const resultPath = state.sources[source]?.lastResultPath;
+    if (!resultPath) {
+        createEmitter(options).info(`No collected dataset found for ${displaySource(source, sourceLabels)}.`);
+        return 1;
+    }
+    process.stdout.write(`${resultPath}\n`);
+    return 0;
+}
 function createEmitter(options) {
+    const renderer = createHumanRenderer();
     return {
         event(event) {
             if (options.json) {
@@ -414,6 +604,54 @@ function createEmitter(options) {
             }
             process.stdout.write(`${message}\n`);
         },
+        blank() {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write("\n");
+        },
+        title(message) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.title(message)}\n`);
+        },
+        section(message) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.section(message)}\n`);
+        },
+        keyValue(label, value, tone = "muted") {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.keyValue(label, value, tone)}\n`);
+        },
+        detail(message) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.detail(message)}\n`);
+        },
+        bullet(message) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.bullet(message)}\n`);
+        },
+        sourceTitle(name, badges = []) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.sourceTitle(name, badges.map((badge) => renderer.badge(badge.text, badge.tone)))}\n`);
+        },
+        badge(text, tone = "muted") {
+            return renderer.badge(text, tone);
+        },
+        code(text) {
+            return renderer.theme.code(text);
+        },
     };
 }
 function displaySource(source, labels = {}) {
@@ -442,6 +680,7 @@ async function gatherSourceStatuses(storedSources, metadata = {}) {
             name: details?.name,
             company: details?.company,
             description: details?.description,
+            authMode: details?.authMode ?? inferInstalledAuthMode(installedFiles, source),
             installed,
             sessionPresent: stored.sessionPresent ?? false,
             lastRunAt: stored.lastRunAt ?? null,
@@ -452,6 +691,7 @@ async function gatherSourceStatuses(storedSources, metadata = {}) {
                     ? "collected_local"
                     : "none",
             lastError: stored.lastError ?? null,
+            lastResultPath: stored.lastResultPath ?? null,
         };
     });
 }
@@ -482,29 +722,30 @@ async function listInstalledConnectorFiles() {
         return [];
     }
 }
-function formatSourceStatus(source, labels = {}) {
+function formatSourceStatus(source, labels = {}, emit) {
+    const authModeSuffix = formatAuthModeBadge(source.authMode, emit);
     if (!source.installed) {
-        return `${displaySource(source.source, labels)}: not connected`;
+        return `${displaySource(source.source, labels)}${authModeSuffix}: not connected`;
     }
     if (!source.lastRunOutcome) {
-        return `${displaySource(source.source, labels)}: installed`;
+        return `${displaySource(source.source, labels)}${authModeSuffix}: installed`;
     }
     if (source.lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT) {
-        return `${displaySource(source.source, labels)}: needs input`;
+        return `${displaySource(source.source, labels)}${authModeSuffix}: needs input`;
     }
     if (source.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
-        return `${displaySource(source.source, labels)}: error`;
+        return `${displaySource(source.source, labels)}${authModeSuffix}: error`;
     }
     if (source.lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
-        return `${displaySource(source.source, labels)}: legacy auth required`;
+        return `${displaySource(source.source, labels)}${authModeSuffix}: manual browser step required`;
     }
     if (source.dataState === "ingested_personal_server") {
-        return `${displaySource(source.source, labels)}: connected, synced`;
+        return `${displaySource(source.source, labels)}${authModeSuffix}: connected, synced`;
     }
     if (source.dataState === "collected_local") {
-        return `${displaySource(source.source, labels)}: connected, local only`;
+        return `${displaySource(source.source, labels)}${authModeSuffix}: connected, local only`;
     }
-    return `${displaySource(source.source, labels)}: connected`;
+    return `${displaySource(source.source, labels)}${authModeSuffix}: connected`;
 }
 function formatSourceStatusDetail(source) {
     if (source.lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT) {
@@ -513,7 +754,7 @@ function formatSourceStatusDetail(source) {
             : `Run \`vana connect ${source.source}\` interactively.`;
     }
     if (source.lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
-        return "This source still uses legacy headed auth and cannot complete in batch mode.";
+        return `Run \`vana connect ${source.source}\` without \`--no-input\` to complete the manual browser step.`;
     }
     if (source.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
         return source.lastError ?? "The last connector run failed.";
@@ -553,9 +794,47 @@ function createSourceMetadataMap(sources) {
             name: source.name,
             company: source.company,
             description: source.description,
+            authMode: source.authMode,
         },
     ]));
 }
+function formatAuthModeBadge(authMode, emit) {
+    if (authMode === "legacy") {
+        return ` ${emit ? emit.badge("legacy", "warning") : "[legacy]"}`;
+    }
+    if (authMode === "interactive") {
+        return ` ${emit ? emit.badge("interactive", "info") : "[interactive]"}`;
+    }
+    return "";
+}
+function toneForRuntime(runtime) {
+    if (runtime === "installed") {
+        return "success";
+    }
+    if (runtime === "missing") {
+        return "warning";
+    }
+    return "muted";
+}
+function inferInstalledAuthMode(installedFiles, source) {
+    const match = installedFiles.find((file) => file.source === source);
+    if (!match) {
+        return undefined;
+    }
+    try {
+        const script = fs.readFileSync(match.path, "utf8");
+        if (/page\.requestInput\(/.test(script)) {
+            return "interactive";
+        }
+        if (/page\.(showBrowser|promptUser)\(/.test(script)) {
+            return "legacy";
+        }
+        return "automated";
+    }
+    catch {
+        return undefined;
+    }
+}
 async function loadRegistrySources() {
     try {
         return ((await listAvailableSources(findDataConnectorsDir() ?? undefined)) ?? []);
@@ -564,4 +843,44 @@ async function loadRegistrySources() {
         return [];
     }
 }
+async function readResultSummary(resultPath) {
+    try {
+        const raw = await fsp.readFile(resultPath, "utf8");
+        return summarizeResultData(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+function summarizeResultData(data) {
+    const lines = [];
+    const exportSummary = typeof data.exportSummary === "object" && data.exportSummary
+        ? data.exportSummary
+        : null;
+    const profile = typeof data.profile === "object" && data.profile
+        ? data.profile
+        : null;
+    if (profile?.username && typeof profile.username === "string") {
+        lines.push(`Profile: ${profile.username}`);
+    }
+    if (Array.isArray(data.repositories)) {
+        lines.push(`Repositories: ${data.repositories.length}`);
+    }
+    if (Array.isArray(data.starred)) {
+        lines.push(`Starred: ${data.starred.length}`);
+    }
+    if (Array.isArray(data.orders)) {
+        lines.push(`Orders: ${data.orders.length}`);
+    }
+    if (exportSummary?.details &&
+        typeof exportSummary.details === "string" &&
+        !lines.includes(exportSummary.details)) {
+        lines.push(exportSummary.details);
+    }
+    return lines.length > 0 ? { lines } : null;
+}
+function isPromptCancelled(error) {
+    return (error instanceof Error &&
+        (error.name === "ExitPromptError" || error.message.includes("SIGINT")));
+}
 //# sourceMappingURL=index.js.map