swarmlancer-cli 0.6.1 → 0.7.0

package/dist/app.js

@@ -2,7 +2,8 @@ import { ProcessTerminal, TUI } from "@mariozechner/pi-tui";
 import { getConfig, getAgents, getAgent, saveAgent, deleteAgent, createAgent, migrateLegacyAgent, } from "./config.js";
 import { login } from "./login.js";
 import { setActiveModel, setAgentInstructions } from "./inference.js";
-import { resolveModel, getAvailableModels, isProviderAuthenticated, saveProviderKey, PROVIDERS, } from "./providers.js";
+import { resolveModel, getAvailableModels, getProviderList, } from "./providers.js";
+import { LoginDialogComponent } from "@mariozechner/pi-coding-agent";
 import { startAgent, stopAgent, sendToServer } from "./agent.js";
 import { colors } from "./theme.js";
 import { DashboardScreen } from "./screens/dashboard.js";
@@ -91,7 +92,7 @@ function editDiscovery(agent) {
 }
 function editModel(agent) {
     return new Promise(async (resolve) => {
-        const models = getAvailableModels();
+        const models = await getAvailableModels();
         if (models.length === 0) {
             await showMessage("No models", ["No provider API keys configured.", "Add one in Manage → Providers."], "error");
             resolve();
@@ -208,10 +209,10 @@ async function runSwarm() {
 async function runProviders() {
     let idx = 0;
     while (true) {
-        const items = PROVIDERS.map((p) => {
-            const loggedIn = isProviderAuthenticated(p.id);
-            const prefix = loggedIn ? "→ " : "  ";
-            const suffix = loggedIn ? " ✓ logged in" : "";
+        const providers = await getProviderList();
+        const items = providers.map((p) => {
+            const prefix = p.loggedIn ? "→ " : "  ";
+            const suffix = p.loggedIn ? " ✓" : "";
             return { value: p.id, label: `${prefix}${p.label}${suffix}`, description: "" };
         });
         const result = await new Promise((resolve) => {
@@ -223,18 +224,13 @@ async function runProviders() {
         if (!result.value)
             return;
         idx = result.index;
-        const provider = PROVIDERS.find((p) => p.id === result.value);
-        if (!provider)
-            continue;
-        if (!provider.keyBased) {
-            await showMessage("Coming soon", [`${provider.label} is not yet supported.`], "info");
-            continue;
-        }
-        const key = await askName(provider.label);
-        if (key) {
-            saveProviderKey(provider.id, key);
-            await showMessage("Saved", [`${provider.label} API key saved.`], "success");
-        }
+        // Use pi's LoginDialogComponent for the OAuth/login flow
+        await new Promise((resolve) => {
+            const dialog = new LoginDialogComponent(tui, result.value, (success, message) => {
+                resolve();
+            });
+            setScreen(dialog);
+        });
     }
 }
 // ── Manage (top) ──────────────────────────────────────────
@@ -294,14 +290,14 @@ async function goOnline() {
     const agent = await pickAgent();
     if (!agent)
         return;
-    const resolved = resolveModel(agent.modelPattern);
+    const resolved = await resolveModel(agent.modelPattern);
     if (!resolved) {
         await showMessage("No model", ["No provider API keys configured.", "Add one in Manage → Providers."], "error");
         return;
     }
-    setActiveModel(resolved.provider, resolved.model);
+    setActiveModel(resolved.provider, resolved.id);
     setAgentInstructions(agent.instructions);
-    const modelInfo = { provider: resolved.provider, id: resolved.model, name: resolved.model };
+    const modelInfo = { provider: resolved.provider, id: resolved.id, name: resolved.id };
     const config = getConfig();
     const screen = new AgentRunningScreen(tui, modelInfo, config.serverUrl, agent.name);
     const done = new Promise((resolve) => {

package/dist/index.js

@@ -3,6 +3,7 @@ import { runInteractive } from "./app.js";
 import { login } from "./login.js";
 import { getConfig, getAgents, migrateLegacyAgent } from "./config.js";
 import { resolveModel, getAvailableModels } from "./providers.js";
+// Note: resolveModel and getAvailableModels are now async
 import { setActiveModel, setAgentInstructions } from "./inference.js";
 import { startAgent } from "./agent.js";
 async function main() {
@@ -47,7 +48,7 @@ async function main() {
             break;
         }
         case "models": {
-            const models = getAvailableModels();
+            const models = await getAvailableModels();
             if (models.length === 0) {
                 console.log("No models available. Add a provider API key: swarmlancer");
             }
@@ -82,15 +83,15 @@ async function main() {
                 agent = match;
             }
             const modelPattern = flags.model || agent.modelPattern;
-            const resolved = resolveModel(modelPattern);
+            const resolved = await resolveModel(modelPattern);
             if (!resolved) {
                 console.error("No model available. Add a provider API key: swarmlancer");
                 process.exit(1);
             }
-            setActiveModel(resolved.provider, resolved.model);
+            setActiveModel(resolved.provider, resolved.id);
             setAgentInstructions(agent.instructions);
             console.log(`Agent:    ${agent.name}`);
-            console.log(`Model:    ${resolved.provider}/${resolved.model}`);
+            console.log(`Model:    ${resolved.provider}/${resolved.id}`);
             console.log(`Server:   ${config.serverUrl}`);
             startAgent(agent.limits, agent.id, agent.name);
             process.on("SIGINT", () => { console.log("\nAgent shutting down..."); process.exit(0); });

package/dist/inference.d.ts

@@ -1,6 +1,5 @@
-import { type ProviderId } from "./providers.js";
 export declare function setAgentInstructions(instructions: string): void;
-export declare function setActiveModel(provider: ProviderId, model: string): void;
+export declare function setActiveModel(provider: string, model: string): void;
 type Message = {
     role: "user" | "assistant";
     content: string;

package/dist/inference.js

@@ -1,4 +1,4 @@
-import { getProviderKey } from "./providers.js";
+import { getApiKey } from "./providers.js";
 let currentProvider;
 let currentModel;
 let currentAgentInstructions = "";
@@ -11,27 +11,33 @@ export function setActiveModel(provider, model) {
 }
 export async function runInference(systemPrompt, messages) {
     if (!currentProvider || !currentModel) {
-        throw new Error("No model configured. Add a provider API key and select a model.");
+        throw new Error("No model configured. Add a provider and select a model.");
     }
     const fullSystemPrompt = currentAgentInstructions
         ? `${currentAgentInstructions}\n\n---\n\n${systemPrompt}`
         : systemPrompt;
-    switch (currentProvider) {
-        case "anthropic":
-            return callAnthropic(fullSystemPrompt, messages, currentModel);
-        case "openai":
-            return callOpenAI(fullSystemPrompt, messages, currentModel);
-        case "google":
-            return callGoogle(fullSystemPrompt, messages, currentModel);
-        default:
-            throw new Error(`Provider "${currentProvider}" does not support direct API calls yet.`);
+    const apiKey = await getApiKey(currentProvider);
+    if (!apiKey) {
+        throw new Error(`No API key for provider "${currentProvider}". Login first.`);
     }
+    // Route to the correct API based on provider
+    if (currentProvider === "anthropic" || currentProvider === "claude-pro-max") {
+        return callAnthropic(fullSystemPrompt, messages, currentModel, apiKey);
+    }
+    if (currentProvider === "openai" || currentProvider === "openai-codex") {
+        return callOpenAI(fullSystemPrompt, messages, currentModel, apiKey);
+    }
+    if (currentProvider === "google" || currentProvider === "google-gemini-cli" || currentProvider === "google-antigravity") {
+        return callGoogle(fullSystemPrompt, messages, currentModel, apiKey);
+    }
+    if (currentProvider === "github-copilot") {
+        return callOpenAI(fullSystemPrompt, messages, currentModel, apiKey);
+    }
+    // Fallback: try OpenAI-compatible API
+    return callOpenAI(fullSystemPrompt, messages, currentModel, apiKey);
 }
 // ── Anthropic ─────────────────────────────────────────────
-async function callAnthropic(system, messages, model) {
-    const apiKey = getProviderKey("anthropic");
-    if (!apiKey)
-        throw new Error("Anthropic API key not configured");
+async function callAnthropic(system, messages, model, apiKey) {
     const res = await fetch("https://api.anthropic.com/v1/messages", {
         method: "POST",
         headers: {
@@ -39,25 +45,15 @@ async function callAnthropic(system, messages, model) {
             "x-api-key": apiKey,
             "anthropic-version": "2023-06-01",
         },
-        body: JSON.stringify({
-            model,
-            max_tokens: 2048,
-            system,
-            messages,
-        }),
+        body: JSON.stringify({ model, max_tokens: 2048, system, messages }),
     });
-    if (!res.ok) {
-        const body = await res.text();
-        throw new Error(`Anthropic ${res.status}: ${body.slice(0, 200)}`);
-    }
+    if (!res.ok)
+        throw new Error(`Anthropic ${res.status}: ${(await res.text()).slice(0, 200)}`);
     const data = (await res.json());
     return data.content?.[0]?.text || "(no response)";
 }
-// ── OpenAI ────────────────────────────────────────────────
-async function callOpenAI(system, messages, model) {
-    const apiKey = getProviderKey("openai");
-    if (!apiKey)
-        throw new Error("OpenAI API key not configured");
+// ── OpenAI / Copilot ──────────────────────────────────────
+async function callOpenAI(system, messages, model, apiKey) {
     const res = await fetch("https://api.openai.com/v1/chat/completions", {
         method: "POST",
         headers: {
@@ -69,18 +65,13 @@ async function callOpenAI(system, messages, model) {
             messages: [{ role: "system", content: system }, ...messages],
         }),
     });
-    if (!res.ok) {
-        const body = await res.text();
-        throw new Error(`OpenAI ${res.status}: ${body.slice(0, 200)}`);
-    }
+    if (!res.ok)
+        throw new Error(`OpenAI ${res.status}: ${(await res.text()).slice(0, 200)}`);
     const data = (await res.json());
     return data.choices?.[0]?.message?.content || "(no response)";
 }
 // ── Google Gemini ─────────────────────────────────────────
-async function callGoogle(system, messages, model) {
-    const apiKey = getProviderKey("google");
-    if (!apiKey)
-        throw new Error("Google API key not configured");
+async function callGoogle(system, messages, model, apiKey) {
     const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
     const contents = messages.map((m) => ({
         role: m.role === "assistant" ? "model" : "user",
@@ -94,10 +85,8 @@ async function callGoogle(system, messages, model) {
             contents,
         }),
     });
-    if (!res.ok) {
-        const body = await res.text();
-        throw new Error(`Google ${res.status}: ${body.slice(0, 200)}`);
-    }
+    if (!res.ok)
+        throw new Error(`Google ${res.status}: ${(await res.text()).slice(0, 200)}`);
     const data = (await res.json());
     return data.candidates?.[0]?.content?.parts?.[0]?.text || "(no response)";
 }

package/dist/providers.d.ts

@@ -1,30 +1,46 @@
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
 export type ModelInfo = {
     provider: string;
     id: string;
     name: string;
 };
-export type ProviderId = "anthropic" | "openai" | "google" | "copilot" | "antigravity";
-export type ProviderDef = {
-    id: ProviderId;
+/**
+ * Get the AuthStorage instance (for login/logout flows).
+ */
+export declare function getAuthStorage(): AuthStorage;
+/**
+ * Get all available models (from providers the user has credentials for).
+ */
+export declare function getAvailableModels(): Promise<ModelInfo[]>;
+/**
+ * Get all known models (regardless of auth status).
+ */
+export declare function getAllModels(): ModelInfo[];
+/**
+ * Get all OAuth provider IDs that the user can /login to.
+ */
+export declare function getOAuthProviders(): {
+    id: string;
+    name: string;
+    loggedIn: boolean;
+}[];
+/**
+ * Get list of providers with auth status for display.
+ */
+export declare function getProviderList(): Promise<{
+    id: string;
     label: string;
-    keyBased: boolean;
-    models: {
-        id: string;
-        name: string;
-    }[];
-};
-export declare const PROVIDERS: ProviderDef[];
-export declare function getProviderKey(id: ProviderId): string | undefined;
-export declare function saveProviderKey(id: ProviderId, apiKey: string): void;
-export declare function removeProviderKey(id: ProviderId): void;
-export declare function getAuthenticatedProviderIds(): ProviderId[];
-export declare function isProviderAuthenticated(id: ProviderId): boolean;
-export declare function getAvailableModels(): ModelInfo[];
-/**
- * Resolve a model pattern like "anthropic/claude-haiku-4-20250514" or just "claude-haiku-4-20250514"
- * into a { provider, model } pair. Falls back to the cheapest available model.
- */
-export declare function resolveModel(modelPattern?: string): {
-    provider: ProviderId;
-    model: string;
-} | undefined;
+    loggedIn: boolean;
+}[]>;
+/**
+ * Check if a provider has any auth configured.
+ */
+export declare function isProviderAuthenticated(providerId: string): boolean;
+/**
+ * Get the API key for a provider (resolves OAuth tokens, env vars, auth.json).
+ */
+export declare function getApiKey(providerId: string): Promise<string | undefined>;
+/**
+ * Resolve a model pattern to a specific available model.
+ */
+export declare function resolveModel(modelPattern?: string): Promise<ModelInfo | undefined>;

package/dist/providers.js

@@ -1,102 +1,112 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-const CONFIG_DIR = join(homedir(), ".swarmlancer");
-const PROVIDERS_FILE = join(CONFIG_DIR, "providers.json");
-// ── Known providers ───────────────────────────────────────
-export const PROVIDERS = [
-    {
-        id: "anthropic",
-        label: "Anthropic (Claude Pro/Max)",
-        keyBased: true,
-        models: [
-            { id: "claude-sonnet-4-20250514", name: "Claude Sonnet 4" },
-            { id: "claude-haiku-4-20250514", name: "Claude Haiku 4" },
-        ],
-    },
-    {
-        id: "openai",
-        label: "ChatGPT Plus/Pro (Codex Subscription)",
-        keyBased: true,
-        models: [
-            { id: "gpt-4o", name: "GPT-4o" },
-            { id: "gpt-4o-mini", name: "GPT-4o Mini" },
-        ],
-    },
-    {
-        id: "google",
-        label: "Google Cloud Code Assist (Gemini CLI)",
-        keyBased: true,
-        models: [
-            { id: "gemini-2.0-flash", name: "Gemini 2.0 Flash" },
-            { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro" },
-        ],
-    },
-    {
-        id: "copilot",
-        label: "GitHub Copilot",
-        keyBased: false,
-        models: [],
-    },
-    {
-        id: "antigravity",
-        label: "Antigravity (Gemini 3, Claude, GPT-OSS)",
-        keyBased: false,
-        models: [],
-    },
-];
-function readAll() {
-    try {
-        if (existsSync(PROVIDERS_FILE)) {
-            return JSON.parse(readFileSync(PROVIDERS_FILE, "utf-8"));
-        }
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+// ── Singleton instances ───────────────────────────────────
+let authStorage;
+let modelRegistry;
+function getAuth() {
+    if (!authStorage) {
+        authStorage = AuthStorage.create();
     }
-    catch { }
-    return {};
-}
-function writeAll(data) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(PROVIDERS_FILE, JSON.stringify(data, null, 2));
+    return authStorage;
 }
-export function getProviderKey(id) {
-    return readAll()[id]?.apiKey || undefined;
+function getRegistry() {
+    if (!modelRegistry) {
+        modelRegistry = new ModelRegistry(getAuth());
+    }
+    return modelRegistry;
 }
-export function saveProviderKey(id, apiKey) {
-    const all = readAll();
-    all[id] = { apiKey };
-    writeAll(all);
+// ── Public API ────────────────────────────────────────────
+/**
+ * Get the AuthStorage instance (for login/logout flows).
+ */
+export function getAuthStorage() {
+    return getAuth();
 }
-export function removeProviderKey(id) {
-    const all = readAll();
-    delete all[id];
-    writeAll(all);
+/**
+ * Get all available models (from providers the user has credentials for).
+ */
+export async function getAvailableModels() {
+    const registry = getRegistry();
+    const models = await registry.getAvailable();
+    return models.map((m) => ({
+        provider: m.provider,
+        id: m.id,
+        name: m.name,
+    }));
 }
-// ── Queries ───────────────────────────────────────────────
-export function getAuthenticatedProviderIds() {
-    const all = readAll();
-    return Object.keys(all).filter((k) => all[k]?.apiKey);
+/**
+ * Get all known models (regardless of auth status).
+ */
+export function getAllModels() {
+    const registry = getRegistry();
+    return registry.getAll().map((m) => ({
+        provider: m.provider,
+        id: m.id,
+        name: m.name,
+    }));
 }
-export function isProviderAuthenticated(id) {
-    return !!getProviderKey(id);
+/**
+ * Get all OAuth provider IDs that the user can /login to.
+ */
+export function getOAuthProviders() {
+    const auth = getAuth();
+    const oauthProviders = auth.getOAuthProviders();
+    return oauthProviders.map((p) => ({
+        id: p.id,
+        name: p.id, // will be overridden by display name below
+        loggedIn: auth.has(p.id),
+    }));
 }
-export function getAvailableModels() {
-    const authed = getAuthenticatedProviderIds();
-    const models = [];
-    for (const p of PROVIDERS) {
-        if (authed.includes(p.id)) {
-            for (const m of p.models) {
-                models.push({ provider: p.id, id: m.id, name: m.name });
-            }
+/**
+ * Get list of providers with auth status for display.
+ */
+export async function getProviderList() {
+    const auth = getAuth();
+    const registry = getRegistry();
+    // Get OAuth providers
+    const oauthProviders = auth.getOAuthProviders();
+    // Get all unique providers from all models
+    const allModels = registry.getAll();
+    const providerIds = [...new Set(allModels.map((m) => m.provider))];
+    // Build display list
+    const result = [];
+    // OAuth providers first (subscription-based)
+    for (const op of oauthProviders) {
+        result.push({
+            id: op.id,
+            label: op.id,
+            loggedIn: auth.has(op.id),
+        });
+    }
+    // Then API key providers not already in the OAuth list
+    const oauthIds = new Set(oauthProviders.map((p) => p.id));
+    for (const pid of providerIds) {
+        if (!oauthIds.has(pid)) {
+            result.push({
+                id: pid,
+                label: pid,
+                loggedIn: auth.hasAuth(pid),
+            });
         }
     }
-    return models;
+    return result;
+}
+/**
+ * Check if a provider has any auth configured.
+ */
+export function isProviderAuthenticated(providerId) {
+    return getAuth().hasAuth(providerId);
+}
+/**
+ * Get the API key for a provider (resolves OAuth tokens, env vars, auth.json).
+ */
+export async function getApiKey(providerId) {
+    return getAuth().getApiKey(providerId);
 }
 /**
- * Resolve a model pattern like "anthropic/claude-haiku-4-20250514" or just "claude-haiku-4-20250514"
- * into a { provider, model } pair. Falls back to the cheapest available model.
+ * Resolve a model pattern to a specific available model.
  */
-export function resolveModel(modelPattern) {
-    const models = getAvailableModels();
+export async function resolveModel(modelPattern) {
+    const models = await getAvailableModels();
     if (models.length === 0)
         return undefined;
     if (modelPattern) {
@@ -105,15 +115,14 @@ export function resolveModel(modelPattern) {
             const [prov, mod] = modelPattern.split("/", 2);
             const match = models.find((m) => m.provider === prov && m.id === mod);
             if (match)
-                return { provider: match.provider, model: match.id };
+                return match;
         }
         // Fuzzy match
         const match = models.find((m) => m.id.includes(modelPattern) ||
             m.name.toLowerCase().includes(modelPattern.toLowerCase()));
         if (match)
-            return { provider: match.provider, model: match.id };
+            return match;
     }
-    // Default: first available model (cheapest tends to be listed last per provider, but first model overall)
-    const m = models[0];
-    return { provider: m.provider, model: m.id };
+    // Default: first available
+    return models[0];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmlancer-cli",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Swarmlancer CLI — let the swarm begin. Connect your AI agent to a network of other agents.",
   "type": "module",
   "main": "dist/index.js",
@@ -41,6 +41,7 @@
     "typescript": "^5.8.0"
   },
   "dependencies": {
+    "@mariozechner/pi-coding-agent": "^0.58.4",
     "@mariozechner/pi-tui": "^0.58.4",
     "open": "^11.0.0",
     "ws": "^8.19.0"