@justram/pie 0.2.4 → 0.2.6

package/CHANGELOG.md

@@ -12,6 +12,38 @@
 
 ### Removed
 
+## 0.2.6
+
+### Breaking Changes
+
+### Added
+
+- Added SDK helper utilities for checking updates and formatting update notifications.
+- Added CLI update notification that checks npm registry for newer versions.
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## 0.2.5
+
+### Breaking Changes
+
+### Added
+
+- Exported OAuth login helpers from the SDK for Node usage.
+- Added the `examples/sdk-login` example to demonstrate SDK-based OAuth login.
+
+### Changed
+
+- Documented SDK OAuth login usage in the README.
+
+### Fixed
+
+### Removed
+
 ## 0.2.3
 
 ### Breaking Changes

package/README.md

@@ -53,6 +53,20 @@ Run `--login` to authenticate with an OAuth-capable provider. The CLI prints a U
 pie --login openai-codex
 ```
 
+#### SDK login (Node-only)
+
+SDK users can trigger the same OAuth flow programmatically (uses Node prompts and writes to
+`~/.pi/agent/auth.json`):
+
+```ts
+import { loginWithOAuthProvider } from "@justram/pie";
+
+await loginWithOAuthProvider("openai-codex", process.stderr);
+```
+
+If you only need an API key and want auto-refresh, call `resolveApiKeyForProvider(provider, process.stderr)`.
+These helpers are Node-only and are not intended for browser environments.
+
 Supported OAuth providers:
 - `anthropic`
 - `github-copilot`

package/dist/auth.d.ts

@@ -0,0 +1,14 @@
+import type { Writable } from "node:stream";
+import { type OAuthCredentials } from "@mariozechner/pi-ai";
+export type ApiKeyCredential = {
+    type: "api_key";
+    key: string;
+};
+export type OAuthCredential = {
+    type: "oauth";
+} & OAuthCredentials;
+export type AuthCredential = ApiKeyCredential | OAuthCredential;
+export type AuthMap = Record<string, AuthCredential | undefined>;
+export declare function resolveApiKeyForProvider(provider: string, stderr: Writable): Promise<string | undefined>;
+export declare function getSupportedOAuthProviders(): string[];
+export declare function loginWithOAuthProvider(provider: string, stderr: Writable): Promise<string>;

package/dist/auth.js

@@ -0,0 +1,178 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { getEnvApiKey, getOAuthApiKey, getOAuthProviders, loginAnthropic, loginAntigravity, loginGeminiCli, loginGitHubCopilot, loginOpenAICodex, } from "@mariozechner/pi-ai";
+const AUTH_PATH = join(homedir(), ".pi", "agent", "auth.json");
+const OAUTH_PROVIDERS = new Set(getOAuthProviders().map((provider) => provider.id));
+export async function resolveApiKeyForProvider(provider, stderr) {
+    const auth = loadAuth();
+    const authKey = await getKeyFromAuth(provider, auth);
+    if (authKey) {
+        return authKey;
+    }
+    const envKey = getEnvApiKey(provider);
+    if (envKey) {
+        return envKey;
+    }
+    if (!isOAuthProvider(provider)) {
+        return undefined;
+    }
+    return await loginAndResolve(provider, auth, stderr);
+}
+export function getSupportedOAuthProviders() {
+    return getOAuthProviders()
+        .map((provider) => provider.id)
+        .sort();
+}
+export async function loginWithOAuthProvider(provider, stderr) {
+    if (!isOAuthProvider(provider)) {
+        const supported = getSupportedOAuthProviders().join(", ");
+        throw new Error(`Unsupported OAuth provider: ${provider}. Supported: ${supported}`);
+    }
+    const auth = loadAuth();
+    return await loginAndResolve(provider, auth, stderr);
+}
+function loadAuth() {
+    try {
+        const raw = readFileSync(AUTH_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function saveAuth(auth) {
+    const dir = dirname(AUTH_PATH);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    writeFileSync(AUTH_PATH, JSON.stringify(auth, null, 2), "utf-8");
+    chmodSync(AUTH_PATH, 0o600);
+}
+async function getKeyFromAuth(provider, auth) {
+    const entry = auth[provider];
+    if (!entry) {
+        return undefined;
+    }
+    if (entry.type === "api_key") {
+        return entry.key;
+    }
+    if (!isOAuthProvider(provider)) {
+        return undefined;
+    }
+    const result = await getOAuthApiKey(provider, oauthCredentials(auth));
+    if (!result) {
+        return undefined;
+    }
+    auth[provider] = { type: "oauth", ...result.newCredentials };
+    saveAuth(auth);
+    return result.apiKey;
+}
+async function loginAndResolve(provider, auth, stderr) {
+    const result = await getOAuthApiKey(provider, oauthCredentials(auth));
+    if (result) {
+        auth[provider] = { type: "oauth", ...result.newCredentials };
+        saveAuth(auth);
+        return result.apiKey;
+    }
+    writeLine(stderr, `[oauth:${provider}] No credentials found in ${AUTH_PATH}. Starting login...`);
+    const credentials = await login(provider, stderr);
+    auth[provider] = { type: "oauth", ...credentials };
+    saveAuth(auth);
+    const refreshed = await getOAuthApiKey(provider, oauthCredentials(auth));
+    if (!refreshed) {
+        throw new Error(`OAuth login completed, but no credentials were returned for ${provider}`);
+    }
+    auth[provider] = { type: "oauth", ...refreshed.newCredentials };
+    saveAuth(auth);
+    return refreshed.apiKey;
+}
+function oauthCredentials(auth) {
+    const result = {};
+    for (const [key, value] of Object.entries(auth)) {
+        if (value?.type === "oauth") {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function isOAuthProvider(provider) {
+    return OAUTH_PROVIDERS.has(provider);
+}
+async function login(provider, stderr) {
+    switch (provider) {
+        case "anthropic":
+            return await loginAnthropic((url) => {
+                writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
+                writeLine(stderr, url);
+            }, async () => {
+                return await promptOnce("Paste the authorization code:", stderr);
+            });
+        case "github-copilot":
+            return await loginGitHubCopilot({
+                onAuth: (url, instructions) => {
+                    writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
+                    writeLine(stderr, url);
+                    if (instructions)
+                        writeLine(stderr, instructions);
+                },
+                onPrompt: async ({ message }) => {
+                    return await promptOnce(message, stderr);
+                },
+                onProgress: (message) => {
+                    writeLine(stderr, `[oauth:${provider}] ${message}`);
+                },
+            });
+        case "google-gemini-cli":
+            return await loginGeminiCli(({ url, instructions }) => {
+                writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
+                writeLine(stderr, url);
+                if (instructions)
+                    writeLine(stderr, instructions);
+            }, (message) => {
+                writeLine(stderr, `[oauth:${provider}] ${message}`);
+            }, async () => {
+                return await promptOnce("Paste the full redirect URL (or press Enter to wait for browser callback):", stderr);
+            });
+        case "google-antigravity":
+            return await loginAntigravity(({ url, instructions }) => {
+                writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
+                writeLine(stderr, url);
+                if (instructions)
+                    writeLine(stderr, instructions);
+            }, (message) => {
+                writeLine(stderr, `[oauth:${provider}] ${message}`);
+            }, async () => {
+                return await promptOnce("Paste the full redirect URL (or press Enter to wait for browser callback):", stderr);
+            });
+        case "openai-codex":
+            return await loginOpenAICodex({
+                onAuth: ({ url, instructions }) => {
+                    writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
+                    writeLine(stderr, url);
+                    if (instructions)
+                        writeLine(stderr, instructions);
+                },
+                onPrompt: async ({ message }) => {
+                    return await promptOnce(message, stderr);
+                },
+                onProgress: (message) => {
+                    writeLine(stderr, `[oauth:${provider}] ${message}`);
+                },
+                onManualCodeInput: async () => {
+                    return await promptOnce("Paste the authorization code:", stderr);
+                },
+            });
+        default:
+            throw new Error(`OAuth login flow not implemented for provider: ${provider}.`);
+    }
+}
+async function promptOnce(prompt, stderr) {
+    const rl = createInterface({ input: process.stdin, output: stderr });
+    return rl.question(`${prompt} `).finally(() => rl.close());
+}
+function writeLine(stream, message) {
+    stream.write(`${message}\n`);
+}

package/dist/cli/oauth.d.ts

@@ -1,14 +1 @@
-import type { Writable } from "node:stream";
-import { type OAuthCredentials } from "@mariozechner/pi-ai";
-export type ApiKeyCredential = {
-    type: "api_key";
-    key: string;
-};
-export type OAuthCredential = {
-    type: "oauth";
-} & OAuthCredentials;
-export type AuthCredential = ApiKeyCredential | OAuthCredential;
-export type AuthMap = Record<string, AuthCredential | undefined>;
-export declare function resolveApiKeyForProvider(provider: string, stderr: Writable): Promise<string | undefined>;
-export declare function getSupportedOAuthProviders(): string[];
-export declare function loginWithOAuthProvider(provider: string, stderr: Writable): Promise<string>;
+export { type ApiKeyCredential, type AuthCredential, type AuthMap, getSupportedOAuthProviders, loginWithOAuthProvider, type OAuthCredential, resolveApiKeyForProvider, } from "../auth.js";

package/dist/cli/oauth.js

@@ -1,178 +1 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { createInterface } from "node:readline/promises";
-import { getEnvApiKey, getOAuthApiKey, getOAuthProviders, loginAnthropic, loginAntigravity, loginGeminiCli, loginGitHubCopilot, loginOpenAICodex, } from "@mariozechner/pi-ai";
-const AUTH_PATH = join(homedir(), ".pi", "agent", "auth.json");
-const OAUTH_PROVIDERS = new Set(getOAuthProviders().map((provider) => provider.id));
-export async function resolveApiKeyForProvider(provider, stderr) {
-    const auth = loadAuth();
-    const authKey = await getKeyFromAuth(provider, auth);
-    if (authKey) {
-        return authKey;
-    }
-    const envKey = getEnvApiKey(provider);
-    if (envKey) {
-        return envKey;
-    }
-    if (!isOAuthProvider(provider)) {
-        return undefined;
-    }
-    return await loginAndResolve(provider, auth, stderr);
-}
-export function getSupportedOAuthProviders() {
-    return getOAuthProviders()
-        .map((provider) => provider.id)
-        .sort();
-}
-export async function loginWithOAuthProvider(provider, stderr) {
-    if (!isOAuthProvider(provider)) {
-        const supported = getSupportedOAuthProviders().join(", ");
-        throw new Error(`Unsupported OAuth provider: ${provider}. Supported: ${supported}`);
-    }
-    const auth = loadAuth();
-    return await loginAndResolve(provider, auth, stderr);
-}
-function loadAuth() {
-    try {
-        const raw = readFileSync(AUTH_PATH, "utf-8");
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === "object" ? parsed : {};
-    }
-    catch {
-        return {};
-    }
-}
-function saveAuth(auth) {
-    const dir = dirname(AUTH_PATH);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true, mode: 0o700 });
-    }
-    writeFileSync(AUTH_PATH, JSON.stringify(auth, null, 2), "utf-8");
-    chmodSync(AUTH_PATH, 0o600);
-}
-async function getKeyFromAuth(provider, auth) {
-    const entry = auth[provider];
-    if (!entry) {
-        return undefined;
-    }
-    if (entry.type === "api_key") {
-        return entry.key;
-    }
-    if (!isOAuthProvider(provider)) {
-        return undefined;
-    }
-    const result = await getOAuthApiKey(provider, oauthCredentials(auth));
-    if (!result) {
-        return undefined;
-    }
-    auth[provider] = { type: "oauth", ...result.newCredentials };
-    saveAuth(auth);
-    return result.apiKey;
-}
-async function loginAndResolve(provider, auth, stderr) {
-    const result = await getOAuthApiKey(provider, oauthCredentials(auth));
-    if (result) {
-        auth[provider] = { type: "oauth", ...result.newCredentials };
-        saveAuth(auth);
-        return result.apiKey;
-    }
-    writeLine(stderr, `[oauth:${provider}] No credentials found in ${AUTH_PATH}. Starting login...`);
-    const credentials = await login(provider, stderr);
-    auth[provider] = { type: "oauth", ...credentials };
-    saveAuth(auth);
-    const refreshed = await getOAuthApiKey(provider, oauthCredentials(auth));
-    if (!refreshed) {
-        throw new Error(`OAuth login completed, but no credentials were returned for ${provider}`);
-    }
-    auth[provider] = { type: "oauth", ...refreshed.newCredentials };
-    saveAuth(auth);
-    return refreshed.apiKey;
-}
-function oauthCredentials(auth) {
-    const result = {};
-    for (const [key, value] of Object.entries(auth)) {
-        if (value?.type === "oauth") {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function isOAuthProvider(provider) {
-    return OAUTH_PROVIDERS.has(provider);
-}
-async function login(provider, stderr) {
-    switch (provider) {
-        case "anthropic":
-            return await loginAnthropic((url) => {
-                writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
-                writeLine(stderr, url);
-            }, async () => {
-                return await promptOnce("Paste the authorization code:", stderr);
-            });
-        case "github-copilot":
-            return await loginGitHubCopilot({
-                onAuth: (url, instructions) => {
-                    writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
-                    writeLine(stderr, url);
-                    if (instructions)
-                        writeLine(stderr, instructions);
-                },
-                onPrompt: async ({ message }) => {
-                    return await promptOnce(message, stderr);
-                },
-                onProgress: (message) => {
-                    writeLine(stderr, `[oauth:${provider}] ${message}`);
-                },
-            });
-        case "google-gemini-cli":
-            return await loginGeminiCli(({ url, instructions }) => {
-                writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
-                writeLine(stderr, url);
-                if (instructions)
-                    writeLine(stderr, instructions);
-            }, (message) => {
-                writeLine(stderr, `[oauth:${provider}] ${message}`);
-            }, async () => {
-                return await promptOnce("Paste the full redirect URL (or press Enter to wait for browser callback):", stderr);
-            });
-        case "google-antigravity":
-            return await loginAntigravity(({ url, instructions }) => {
-                writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
-                writeLine(stderr, url);
-                if (instructions)
-                    writeLine(stderr, instructions);
-            }, (message) => {
-                writeLine(stderr, `[oauth:${provider}] ${message}`);
-            }, async () => {
-                return await promptOnce("Paste the full redirect URL (or press Enter to wait for browser callback):", stderr);
-            });
-        case "openai-codex":
-            return await loginOpenAICodex({
-                onAuth: ({ url, instructions }) => {
-                    writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
-                    writeLine(stderr, url);
-                    if (instructions)
-                        writeLine(stderr, instructions);
-                },
-                onPrompt: async ({ message }) => {
-                    return await promptOnce(message, stderr);
-                },
-                onProgress: (message) => {
-                    writeLine(stderr, `[oauth:${provider}] ${message}`);
-                },
-                onManualCodeInput: async () => {
-                    return await promptOnce("Paste the authorization code:", stderr);
-                },
-            });
-        default:
-            throw new Error(`OAuth login flow not implemented for provider: ${provider}.`);
-    }
-}
-async function promptOnce(prompt, stderr) {
-    const rl = createInterface({ input: process.stdin, output: stderr });
-    return rl.question(`${prompt} `).finally(() => rl.close());
-}
-function writeLine(stream, message) {
-    stream.write(`${message}\n`);
-}
+export { getSupportedOAuthProviders, loginWithOAuthProvider, resolveApiKeyForProvider, } from "../auth.js";

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { type AssistantMessage, type ImageContent, type Message, type Model, StringEnum, type UserMessage, } from "@mariozechner/pi-ai";
 export { type Static, type TSchema, Type } from "@sinclair/typebox";
+export { type ApiKeyCredential, type AuthCredential, type AuthMap, getSupportedOAuthProviders, loginWithOAuthProvider, type OAuthCredential, resolveApiKeyForProvider, } from "./auth.js";
 export type { CacheEntry, CacheOptions, CacheStore } from "./cache/index.js";
 export { createFileCache, createMemoryCache, warmCache } from "./cache/index.js";
 export { AbortError, CommandValidationError, ExtractError, HttpValidationError, MaxTurnsError, SchemaValidationError, } from "./errors.js";
@@ -11,3 +12,4 @@ export { loadRecipeSetup, loadRecipes, resolveRecipe, } from "./recipes/index.js
 export type { ExtractionSetup, LoadExtractionSetupOptions } from "./setup.js";
 export { loadExtractionSetup } from "./setup.js";
 export type { ExtractOptions, ExtractResult, ExtractStream, ThinkingBudgets, ThinkingLevel, Usage } from "./types.js";
+export { checkForUpdates, formatUpdateNotification, type UpdateInfo } from "./update.js";

package/dist/index.js

@@ -1,8 +1,10 @@
 export { StringEnum, } from "@mariozechner/pi-ai";
 export { Type } from "@sinclair/typebox";
+export { getSupportedOAuthProviders, loginWithOAuthProvider, resolveApiKeyForProvider, } from "./auth.js";
 export { createFileCache, createMemoryCache, warmCache } from "./cache/index.js";
 export { AbortError, CommandValidationError, ExtractError, HttpValidationError, MaxTurnsError, SchemaValidationError, } from "./errors.js";
 export { extract, extractSync } from "./extract.js";
 export { getModel, getModels, getProviders } from "./models.js";
 export { loadRecipeSetup, loadRecipes, resolveRecipe, } from "./recipes/index.js";
 export { loadExtractionSetup } from "./setup.js";
+export { checkForUpdates, formatUpdateNotification } from "./update.js";

package/dist/main.js

@@ -11,6 +11,7 @@ import { loadExtractionSetupFromContent } from "./core/setup.js";
 import { extract } from "./extract.js";
 import { getModels, getProviders } from "./models.js";
 import { loadRecipeSetup, loadRecipes } from "./recipes/index.js";
+import { checkForUpdates, formatUpdateNotification, getVersion } from "./update.js";
 const MODEL_PROVIDER_PREFERENCE = ["anthropic", "openai", "google"];
 class CliExitError extends Error {
     exitCode;
@@ -121,6 +122,7 @@ async function runCliInternal(argv, deps, stdout, stderr) {
         }
         return 0;
     }
+    startVersionCheck(stderr);
     const promptInput = args.promptFile ? readTextFile(args.promptFile, "prompt") : args.prompt;
     const promptPath = args.promptFile ? resolve(args.promptFile) : undefined;
     const promptIsSetup = !args.config && !useRecipe && typeof promptInput === "string" && promptInput.startsWith("---");
@@ -591,11 +593,14 @@ function mapExtractionExitCode(error) {
 function writeLine(stream, message) {
     stream.write(`${message}\n`);
 }
-function getVersion() {
-    const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = readFileSync(pkgPath, "utf8");
-    const pkg = JSON.parse(raw);
-    return pkg.version ?? "0.0.0";
+function startVersionCheck(stderr) {
+    void checkForUpdates().then((info) => {
+        if (!info)
+            return;
+        for (const line of formatUpdateNotification(info)) {
+            writeLine(stderr, line);
+        }
+    });
 }
 async function readStream(stream) {
     return await new Promise((resolveStream, reject) => {

package/dist/update.d.ts

@@ -0,0 +1,10 @@
+export interface UpdateInfo {
+    packageName: string;
+    currentVersion: string;
+    latestVersion: string;
+}
+export declare function getVersion(): string;
+export declare function checkForUpdates(options?: {
+    skipEnv?: boolean;
+}): Promise<UpdateInfo | undefined>;
+export declare function formatUpdateNotification(info: UpdateInfo): string[];

package/dist/update.js

@@ -0,0 +1,42 @@
+import { readFileSync } from "node:fs";
+function getPackageInfo() {
+    const pkgPath = new URL("../package.json", import.meta.url);
+    const raw = readFileSync(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    return {
+        name: pkg.name ?? "pie",
+        version: pkg.version ?? "0.0.0",
+    };
+}
+export function getVersion() {
+    return getPackageInfo().version;
+}
+export async function checkForUpdates(options = {}) {
+    if (!options.skipEnv && process.env.PI_SKIP_VERSION_CHECK)
+        return undefined;
+    const { name, version } = getPackageInfo();
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${name}/latest`);
+        if (!response.ok)
+            return undefined;
+        const data = (await response.json());
+        const latestVersion = data.version;
+        if (latestVersion && latestVersion !== version) {
+            return {
+                packageName: name,
+                currentVersion: version,
+                latestVersion,
+            };
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function formatUpdateNotification(info) {
+    return [
+        `Update available for ${info.packageName}: v${info.latestVersion} (current v${info.currentVersion}). Run: npm install -g ${info.packageName}`,
+        "Changelog: https://github.com/justram/pie/blob/main/CHANGELOG.md",
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@justram/pie",
-	"version": "0.2.4",
+	"version": "0.2.6",
 	"description": "Structured extraction library and CLI built on @mariozechner/pi-ai.",
 	"homepage": "https://github.com/justram/pie#readme",
 	"repository": {