@cremini/skillpack 1.1.9 → 1.2.1

package/dist/cli.js

@@ -9,89 +9,46 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/runtime/adapters/attachment-utils.ts
+// src/runtime/config.ts
 import fs5 from "fs";
 import path5 from "path";
-import { pipeline } from "stream/promises";
-import { Readable } from "stream";
-function getAttachmentDir(rootDir, channelId) {
-  return path5.resolve(rootDir, "data", "sessions", channelId, ATTACHMENTS_DIR);
-}
-function sanitizeFilename(name) {
-  return name.replace(/[/\\:*?"<>|]/g, "_").replace(/\s+/g, "_");
-}
-async function downloadAndSaveAttachment(rootDir, channelId, url, filename, mimeType, headers) {
-  const dir = getAttachmentDir(rootDir, channelId);
-  fs5.mkdirSync(dir, { recursive: true });
-  const ts = Date.now();
-  const safeName = sanitizeFilename(filename);
-  const storedName = `${ts}-${safeName}`;
-  const fullPath = path5.join(dir, storedName);
-  const response = await fetch(url, { headers });
-  if (!response.ok) {
-    throw new Error(
-      `Failed to download attachment from ${url}: ${response.status} ${response.statusText}`
-    );
-  }
-  const body = response.body;
-  if (!body) {
-    throw new Error(`Empty response body when downloading ${url}`);
-  }
-  const nodeStream = Readable.fromWeb(body);
-  const writeStream = fs5.createWriteStream(fullPath);
-  await pipeline(nodeStream, writeStream);
-  const stats = fs5.statSync(fullPath);
-  const detectedMime = mimeType || response.headers.get("content-type")?.split(";")[0] || void 0;
-  return {
-    filename,
-    localPath: fullPath,
-    mimeType: detectedMime,
-    size: stats.size
-  };
-}
-function isImageMime(mimeType) {
-  return !!mimeType && mimeType.startsWith("image/");
-}
-function formatSize(bytes) {
-  if (bytes === void 0 || bytes === null) return "";
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
-function formatAttachmentsPrompt(attachments) {
-  if (attachments.length === 0) return "";
-  const lines = attachments.map((a) => {
-    const meta = [a.mimeType, formatSize(a.size)].filter(Boolean).join(", ");
-    return `- ${a.filename} (${meta}) \u2192 ${a.localPath}`;
-  });
-  return `[Attachments]
-${lines.join("\n")}`;
-}
-function attachmentsToImageContent(attachments) {
-  return attachments.filter((a) => isImageMime(a.mimeType)).map((a) => {
-    const buffer = fs5.readFileSync(a.localPath);
-    return {
-      type: "image",
-      data: buffer.toString("base64"),
-      mimeType: a.mimeType || "image/png"
-    };
-  });
-}
-var ATTACHMENTS_DIR;
-var init_attachment_utils = __esm({
-  "src/runtime/adapters/attachment-utils.ts"() {
-    "use strict";
-    ATTACHMENTS_DIR = "attachments";
-  }
-});
-
-// src/runtime/config.ts
-import fs8 from "fs";
-import path8 from "path";
-var ConfigManager, configManager;
+var SUPPORTED_PROVIDERS, ConfigManager, configManager, ConfigFileAuthBackend;
 var init_config = __esm({
   "src/runtime/config.ts"() {
     "use strict";
+    SUPPORTED_PROVIDERS = {
+      openai: {
+        label: "OpenAI",
+        defaultModelId: "gpt-5.4",
+        authType: "api_key",
+        envKey: "OPENAI_API_KEY",
+        placeholder: "sk-proj-...",
+        supportsBaseUrl: true
+      },
+      anthropic: {
+        label: "Anthropic",
+        defaultModelId: "claude-opus-4-6",
+        authType: "api_key",
+        envKey: "ANTHROPIC_API_KEY",
+        placeholder: "sk-ant-api03-...",
+        supportsBaseUrl: true
+      },
+      google: {
+        label: "Google (Gemini)",
+        defaultModelId: "gemini-2.5-pro",
+        authType: "api_key",
+        envKey: "GOOGLE_API_KEY",
+        placeholder: "AIza...",
+        supportsBaseUrl: false
+      },
+      "openai-codex": {
+        label: "OpenAI Codex",
+        defaultModelId: "gpt-5.4",
+        authType: "oauth",
+        oauthProviderId: "openai-codex",
+        supportsBaseUrl: false
+      }
+    };
     ConfigManager = class _ConfigManager {
       static instance;
       configData = {};
@@ -105,10 +62,10 @@ var init_config = __esm({
         return _ConfigManager.instance;
       }
       load(rootDir) {
-        this.configPath = path8.join(rootDir, "data", "config.json");
-        if (fs8.existsSync(this.configPath)) {
+        this.configPath = path5.join(rootDir, "data", "config.json");
+        if (fs5.existsSync(this.configPath)) {
           try {
-            this.configData = JSON.parse(fs8.readFileSync(this.configPath, "utf-8"));
+            this.configData = JSON.parse(fs5.readFileSync(this.configPath, "utf-8"));
             console.log("  Loaded config from data/config.json");
           } catch (err) {
             console.warn("  Warning: Failed to parse data/config.json:", err);
@@ -122,6 +79,9 @@ var init_config = __esm({
           } else if (process.env.ANTHROPIC_API_KEY) {
             apiKey = process.env.ANTHROPIC_API_KEY;
             provider = "anthropic";
+          } else if (process.env.GOOGLE_API_KEY) {
+            apiKey = process.env.GOOGLE_API_KEY;
+            provider = "google";
           }
         }
         this.configData.apiKey = apiKey;
@@ -133,12 +93,12 @@ var init_config = __esm({
         return this.configData;
       }
       save(rootDir, updates) {
-        const configDir = path8.join(rootDir, "data");
+        const configDir = path5.join(rootDir, "data");
         if (!this.configPath) {
-          this.configPath = path8.join(rootDir, "data", "config.json");
+          this.configPath = path5.join(rootDir, "data", "config.json");
         }
-        if (!fs8.existsSync(configDir)) {
-          fs8.mkdirSync(configDir, { recursive: true });
+        if (!fs5.existsSync(configDir)) {
+          fs5.mkdirSync(configDir, { recursive: true });
         }
         if (updates.apiKey !== void 0) this.configData.apiKey = updates.apiKey;
         if (updates.provider !== void 0) this.configData.provider = updates.provider;
@@ -160,7 +120,7 @@ var init_config = __esm({
           this.configData.scheduledJobs = updates.scheduledJobs;
         }
         try {
-          fs8.writeFileSync(
+          fs5.writeFileSync(
             this.configPath,
             JSON.stringify(this.configData, null, 2),
             "utf-8"
@@ -171,6 +131,137 @@ var init_config = __esm({
       }
     };
     configManager = ConfigManager.getInstance();
+    ConfigFileAuthBackend = class {
+      constructor(configPath) {
+        this.configPath = configPath;
+      }
+      ensureFile() {
+        const dir = path5.dirname(this.configPath);
+        if (!fs5.existsSync(dir)) {
+          fs5.mkdirSync(dir, { recursive: true });
+        }
+        if (!fs5.existsSync(this.configPath)) {
+          fs5.writeFileSync(this.configPath, "{}", "utf-8");
+        }
+      }
+      readAuthJson() {
+        this.ensureFile();
+        try {
+          const raw = fs5.readFileSync(this.configPath, "utf-8");
+          const config = JSON.parse(raw);
+          if (config._auth && typeof config._auth === "object") {
+            return JSON.stringify(config._auth);
+          }
+          return void 0;
+        } catch {
+          return void 0;
+        }
+      }
+      writeAuthJson(authJson) {
+        this.ensureFile();
+        try {
+          const raw = fs5.readFileSync(this.configPath, "utf-8");
+          const config = JSON.parse(raw);
+          config._auth = JSON.parse(authJson);
+          fs5.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+        } catch {
+          const config = { _auth: JSON.parse(authJson) };
+          fs5.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+        }
+      }
+      withLock(fn) {
+        const current = this.readAuthJson();
+        const { result, next } = fn(current);
+        if (next !== void 0) {
+          this.writeAuthJson(next);
+        }
+        return result;
+      }
+      async withLockAsync(fn) {
+        const current = this.readAuthJson();
+        const { result, next } = await fn(current);
+        if (next !== void 0) {
+          this.writeAuthJson(next);
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/runtime/adapters/attachment-utils.ts
+import fs6 from "fs";
+import path6 from "path";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+function getAttachmentDir(rootDir, channelId) {
+  return path6.resolve(rootDir, "data", "sessions", channelId, ATTACHMENTS_DIR);
+}
+function sanitizeFilename(name) {
+  return name.replace(/[/\\:*?"<>|]/g, "_").replace(/\s+/g, "_");
+}
+async function downloadAndSaveAttachment(rootDir, channelId, url, filename, mimeType, headers) {
+  const dir = getAttachmentDir(rootDir, channelId);
+  fs6.mkdirSync(dir, { recursive: true });
+  const ts = Date.now();
+  const safeName = sanitizeFilename(filename);
+  const storedName = `${ts}-${safeName}`;
+  const fullPath = path6.join(dir, storedName);
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download attachment from ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  const body = response.body;
+  if (!body) {
+    throw new Error(`Empty response body when downloading ${url}`);
+  }
+  const nodeStream = Readable.fromWeb(body);
+  const writeStream = fs6.createWriteStream(fullPath);
+  await pipeline(nodeStream, writeStream);
+  const stats = fs6.statSync(fullPath);
+  const detectedMime = mimeType || response.headers.get("content-type")?.split(";")[0] || void 0;
+  return {
+    filename,
+    localPath: fullPath,
+    mimeType: detectedMime,
+    size: stats.size
+  };
+}
+function isImageMime(mimeType) {
+  return !!mimeType && mimeType.startsWith("image/");
+}
+function formatSize(bytes) {
+  if (bytes === void 0 || bytes === null) return "";
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+function formatAttachmentsPrompt(attachments) {
+  if (attachments.length === 0) return "";
+  const lines = attachments.map((a) => {
+    const meta = [a.mimeType, formatSize(a.size)].filter(Boolean).join(", ");
+    return `- ${a.filename} (${meta}) \u2192 ${a.localPath}`;
+  });
+  return `[Attachments]
+${lines.join("\n")}`;
+}
+function attachmentsToImageContent(attachments) {
+  return attachments.filter((a) => isImageMime(a.mimeType)).map((a) => {
+    const buffer = fs6.readFileSync(a.localPath);
+    return {
+      type: "image",
+      data: buffer.toString("base64"),
+      mimeType: a.mimeType || "image/png"
+    };
+  });
+}
+var ATTACHMENTS_DIR;
+var init_attachment_utils = __esm({
+  "src/runtime/adapters/attachment-utils.ts"() {
+    "use strict";
+    ATTACHMENTS_DIR = "attachments";
   }
 });
 
@@ -293,7 +384,7 @@ var telegram_exports = {};
 __export(telegram_exports, {
   TelegramAdapter: () => TelegramAdapter
 });
-import fs10 from "fs";
+import fs11 from "fs";
 import TelegramBot from "node-telegram-bot-api";
 var COMMANDS2, MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
 var init_telegram = __esm({
@@ -604,7 +695,7 @@ var init_telegram = __esm({
       async sendFileSafe(chatId, filePath, caption) {
         if (!this.bot) return;
         try {
-          if (!fs10.existsSync(filePath)) {
+          if (!fs11.existsSync(filePath)) {
             console.error(`[Telegram] File not found for sending: ${filePath}`);
             return;
           }
@@ -624,8 +715,8 @@ var slack_exports = {};
 __export(slack_exports, {
   SlackAdapter: () => SlackAdapter
 });
-import fs11 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 from "path";
 import { App, LogLevel } from "@slack/bolt";
 var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, SlackAdapter;
 var init_slack = __esm({
@@ -1103,12 +1194,12 @@ var init_slack = __esm({
        */
       async sendFileSafe(client, route, filePath, caption) {
         try {
-          if (!fs11.existsSync(filePath)) {
+          if (!fs12.existsSync(filePath)) {
             console.error(`[Slack] File not found for sending: ${filePath}`);
             return;
           }
-          const filename = path10.basename(filePath);
-          const fileContent = fs11.readFileSync(filePath);
+          const filename = path11.basename(filePath);
+          const fileContent = fs12.readFileSync(filePath);
           await client.files.uploadV2({
             channel_id: route.channel,
             thread_ts: route.threadTs,
@@ -2043,23 +2134,24 @@ async function interactiveCreate(workDir) {
 }
 
 // src/commands/run.ts
-import path12 from "path";
-import fs13 from "fs";
+import path13 from "path";
+import fs14 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 
 // src/runtime/server.ts
 import express from "express";
-import path11 from "path";
-import fs12 from "fs";
+import path12 from "path";
+import fs13 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createServer } from "http";
 import { exec } from "child_process";
 
 // src/runtime/agent.ts
+init_config();
 init_attachment_utils();
-import path7 from "path";
-import fs7 from "fs";
+import path8 from "path";
+import fs8 from "fs";
 import { fileURLToPath } from "url";
 import {
   AuthStorage,
@@ -2071,8 +2163,8 @@ import {
 } from "@mariozechner/pi-coding-agent";
 
 // src/runtime/tools/send-file-tool.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var value_exports = {};
@@ -4712,7 +4804,7 @@ var MIME_BY_EXT = {
   ".ogg": "audio/ogg"
 };
 function detectMimeType(filePath) {
-  const ext = path6.extname(filePath).toLowerCase();
+  const ext = path7.extname(filePath).toLowerCase();
   return MIME_BY_EXT[ext];
 }
 function createSendFileTool(fileOutputCallbackRef) {
@@ -4724,13 +4816,13 @@ function createSendFileTool(fileOutputCallbackRef) {
     parameters: SendFileParams,
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
       const { filePath, caption } = params;
-      if (!fs6.existsSync(filePath)) {
+      if (!fs7.existsSync(filePath)) {
         return {
           content: [{ type: "text", text: `Error: File not found: ${filePath}` }],
           details: void 0
         };
       }
-      const stats = fs6.statSync(filePath);
+      const stats = fs7.statSync(filePath);
       if (!stats.isFile()) {
         return {
           content: [
@@ -4739,7 +4831,7 @@ function createSendFileTool(fileOutputCallbackRef) {
           details: void 0
         };
       }
-      const filename = path6.basename(filePath);
+      const filename = path7.basename(filePath);
       const mimeType = detectMimeType(filePath);
       const callback = fileOutputCallbackRef.current;
       if (callback) {
@@ -4925,24 +5017,24 @@ var BUILTIN_SKILL_CREATOR_TEMPLATE_DIR = fileURLToPath(
   new URL("../templates/builtin-skills/skill-creator", import.meta.url)
 );
 function materializeBuiltinSkillCreator(rootDir, skillsPath) {
-  if (!fs7.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
+  if (!fs8.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
     log(
       `[PackAgent] Built-in skill-creator template missing: ${BUILTIN_SKILL_CREATOR_TEMPLATE_DIR}`
     );
     return null;
   }
-  const packConfigPath = path7.resolve(rootDir, "skillpack.json");
-  const skillDir = path7.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
-  const skillPath = path7.join(skillDir, "SKILL.md");
+  const packConfigPath = path8.resolve(rootDir, "skillpack.json");
+  const skillDir = path8.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
+  const skillPath = path8.join(skillDir, "SKILL.md");
   const renderTemplate = (content) => content.replaceAll("{{SKILLS_PATH}}", skillsPath).replaceAll("{{PACK_CONFIG_PATH}}", packConfigPath);
   const copyDir = (srcDir, destDir) => {
-    fs7.mkdirSync(destDir, { recursive: true });
-    for (const entry of fs7.readdirSync(srcDir, { withFileTypes: true })) {
+    fs8.mkdirSync(destDir, { recursive: true });
+    for (const entry of fs8.readdirSync(srcDir, { withFileTypes: true })) {
       if (entry.name === ".DS_Store") {
         continue;
       }
-      const srcPath = path7.join(srcDir, entry.name);
-      const destPath = path7.join(destDir, entry.name);
+      const srcPath = path8.join(srcDir, entry.name);
+      const destPath = path8.join(destDir, entry.name);
       if (entry.isDirectory()) {
         copyDir(srcPath, destPath);
         continue;
@@ -4951,17 +5043,17 @@ function materializeBuiltinSkillCreator(rootDir, skillsPath) {
         continue;
       }
       if (entry.name.endsWith(".md") || entry.name.endsWith(".py")) {
-        const content = fs7.readFileSync(srcPath, "utf-8");
-        fs7.writeFileSync(destPath, renderTemplate(content), "utf-8");
+        const content = fs8.readFileSync(srcPath, "utf-8");
+        fs8.writeFileSync(destPath, renderTemplate(content), "utf-8");
         continue;
       }
-      fs7.copyFileSync(srcPath, destPath);
+      fs8.copyFileSync(srcPath, destPath);
     }
   };
-  if (!fs7.existsSync(skillDir)) {
+  if (!fs8.existsSync(skillDir)) {
     copyDir(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR, skillDir);
   }
-  if (!fs7.existsSync(skillPath)) {
+  if (!fs8.existsSync(skillPath)) {
     log(
       `[PackAgent] Materialized built-in skill-creator but SKILL.md is missing: ${skillPath}`
     );
@@ -5014,8 +5106,29 @@ var PackAgent = class {
     current: null
   };
   schedulerRef = { current: null };
+  authStorage;
   constructor(options) {
     this.options = options;
+    const configPath = path8.resolve(options.rootDir, "data", "config.json");
+    const backend = new ConfigFileAuthBackend(configPath);
+    this.authStorage = AuthStorage.fromStorage(backend);
+    const providerMeta = SUPPORTED_PROVIDERS[options.provider];
+    if (providerMeta?.authType === "api_key" && options.apiKey) {
+      this.authStorage.setRuntimeApiKey(options.provider, options.apiKey);
+    }
+  }
+  /** Get the shared AuthStorage instance (used by OAuth API endpoints) */
+  getAuthStorage() {
+    return this.authStorage;
+  }
+  /** Update runtime auth when provider/apiKey changes */
+  updateAuth(provider, apiKey) {
+    this.authStorage.removeRuntimeApiKey(this.options.provider);
+    this.options.provider = provider;
+    if (apiKey) {
+      this.options.apiKey = apiKey;
+      this.authStorage.setRuntimeApiKey(provider, apiKey);
+    }
   }
   /**
    * Inject scheduler reference (called by server.ts after adapter init).
@@ -5039,35 +5152,32 @@ var PackAgent = class {
     const pendingCreation = this.pendingSessionCreations.get(channelId);
     if (pendingCreation) return pendingCreation;
     const createSessionPromise = (async () => {
-      const { apiKey, rootDir, provider, modelId, baseUrl } = this.options;
-      const authStorage = AuthStorage.inMemory({
-        [provider]: { type: "api_key", key: apiKey }
-      });
-      authStorage.setRuntimeApiKey(provider, apiKey);
+      const { rootDir, provider, modelId, baseUrl } = this.options;
+      const authStorage = this.authStorage;
       const modelRegistry = new ModelRegistry(authStorage);
       const resolvedModel = modelRegistry.find(provider, modelId);
       const model = resolvedModel && baseUrl ? { ...resolvedModel, baseUrl } : resolvedModel;
       if (resolvedModel && baseUrl) {
         log(`[PackAgent] Overriding ${provider}/${modelId} baseUrl -> ${baseUrl}`);
       }
-      const sessionDir = path7.resolve(
+      const sessionDir = path8.resolve(
         rootDir,
         "data",
         "sessions",
         channelId
       );
-      fs7.mkdirSync(sessionDir, { recursive: true });
+      fs8.mkdirSync(sessionDir, { recursive: true });
       const sessionManager = SessionManager.continueRecent(rootDir, sessionDir);
       log(`[PackAgent] Session dir: ${sessionDir}`);
-      const workspaceDir = path7.resolve(
+      const workspaceDir = path8.resolve(
         rootDir,
         "data",
         "workspaces",
         channelId
       );
-      fs7.mkdirSync(workspaceDir, { recursive: true });
+      fs8.mkdirSync(workspaceDir, { recursive: true });
       log(`[PackAgent] Workspace dir: ${workspaceDir}`);
-      const skillsPath = path7.resolve(rootDir, "skills");
+      const skillsPath = path8.resolve(rootDir, "skills");
       log(`[PackAgent] Loading skills from: ${skillsPath}`);
       const materializedSkillCreator = materializeBuiltinSkillCreator(
         rootDir,
@@ -5249,9 +5359,9 @@ ${text}`;
           this.channels.delete(channelId);
         }
         const { rootDir } = this.options;
-        const sessionDir = path7.resolve(rootDir, "data", "sessions", channelId);
-        if (fs7.existsSync(sessionDir)) {
-          fs7.rmSync(sessionDir, { recursive: true, force: true });
+        const sessionDir = path8.resolve(rootDir, "data", "sessions", channelId);
+        if (fs8.existsSync(sessionDir)) {
+          fs8.rmSync(sessionDir, { recursive: true, force: true });
           log(`[PackAgent] Cleared session dir: ${sessionDir}`);
         }
         return {
@@ -5340,6 +5450,9 @@ var WebAdapter = class {
     app.get("/api/config", (_req, res) => {
       const config = getPackConfig(rootDir);
       const conf = configManager.getConfig();
+      const currentProvider2 = conf.provider || "openai";
+      const providerMeta = SUPPORTED_PROVIDERS[currentProvider2];
+      const oauthConnected = providerMeta?.authType === "oauth" ? agent.getAuthStorage().hasAuth(currentProvider2) : false;
       res.json({
         name: config.name,
         description: config.description,
@@ -5347,10 +5460,11 @@ var WebAdapter = class {
         skills: config.skills || [],
         hasApiKey: !!conf.apiKey,
         apiKey: conf.apiKey || "",
-        provider: conf.provider || "openai",
+        provider: currentProvider2,
         baseUrl: conf.baseUrl || "",
         adapters: conf.adapters || {},
-        runtimeControl: lifecycle.getRuntimeControl()
+        supportedProviders: SUPPORTED_PROVIDERS,
+        oauthConnected
       });
     });
     app.get("/api/skills", (_req, res) => {
@@ -5376,29 +5490,65 @@ var WebAdapter = class {
         updates.adapters = adapters;
       }
       configManager.save(rootDir, updates);
-      const newConf = configManager.getConfig();
-      const requiresRestart = getRuntimeConfigSignature(beforeConfig) !== getRuntimeConfigSignature(newConf);
+      agent.updateAuth(currentProvider, apiKey);
+      const afterConfig = configManager.getConfig();
+      const requiresRestart = getRuntimeConfigSignature(beforeConfig) !== getRuntimeConfigSignature(afterConfig);
       res.json({
-        success: true,
-        provider: newConf.provider,
-        baseUrl: newConf.baseUrl || "",
-        adapters: newConf.adapters,
-        requiresRestart,
-        runtimeControl: lifecycle.getRuntimeControl()
+        ...afterConfig,
+        requiresRestart
       });
     });
-    app.post("/api/runtime/restart", async (_req, res) => {
-      const runtimeControl = lifecycle.getRuntimeControl();
-      if (!runtimeControl.canManagedRestart) {
-        res.status(409).json({
-          success: false,
-          message: "Managed restart is unavailable for this process.",
-          runtimeControl
+    app.post("/api/oauth/login", async (req, res) => {
+      const { provider } = req.body;
+      const meta = SUPPORTED_PROVIDERS[provider];
+      if (!meta || meta.authType !== "oauth") {
+        return res.status(400).json({ error: "Provider does not support OAuth" });
+      }
+      try {
+        const authStorage = agent.getAuthStorage();
+        let authUrl = "";
+        const loginPromise = authStorage.login(provider, {
+          onAuth: (info) => {
+            authUrl = info.url;
+          },
+          onPrompt: async (prompt) => {
+            return "";
+          },
+          onProgress: (msg) => {
+            console.log(`[OAuth] ${provider} login progress: ${msg}`);
+          }
         });
-        return;
+        await new Promise((r) => setTimeout(r, 1500));
+        if (authUrl) {
+          res.json({ status: "pending", authUrl });
+        } else {
+          res.json({ status: "pending" });
+        }
+        loginPromise.catch((err) => {
+          console.error(`[OAuth] ${provider} login error:`, err);
+        });
+      } catch (err) {
+        res.status(500).json({ error: String(err) });
+      }
+    });
+    app.get("/api/oauth/status", (_req, res) => {
+      const conf = configManager.getConfig();
+      const provider = conf.provider || "openai";
+      const meta = SUPPORTED_PROVIDERS[provider];
+      if (!meta || meta.authType !== "oauth") {
+        return res.json({ connected: false });
       }
+      const connected = agent.getAuthStorage().hasAuth(provider);
+      res.json({ connected, provider });
+    });
+    app.post("/api/oauth/logout", (req, res) => {
+      const { provider } = req.body;
+      agent.getAuthStorage().logout(provider);
+      res.json({ success: true });
+    });
+    app.post("/api/runtime/restart", async (_req, res) => {
       const result = await lifecycle.requestRestart("web");
-      res.status(202).json({ ...result, runtimeControl });
+      res.status(202).json(result);
     });
     app.delete("/api/chat", (_req, res) => {
       res.json({ success: true });
@@ -5519,8 +5669,10 @@ var WebAdapter = class {
         `http://${request.headers.host || "127.0.0.1"}`
       );
       const _reqProvider = url.searchParams.get("provider") || currentProvider;
-      if (!apiKey) {
-        ws.send(JSON.stringify({ error: "Please set an API key first" }));
+      const providerMeta = SUPPORTED_PROVIDERS[_reqProvider];
+      const hasAuth = providerMeta?.authType === "oauth" ? agent.getAuthStorage().hasAuth(_reqProvider) : !!apiKey;
+      if (!hasAuth) {
+        ws.send(JSON.stringify({ error: "Please configure authentication first" }));
         ws.close();
         return;
       }
@@ -5590,29 +5742,18 @@ init_config();
 var SHUTDOWN_EXIT_CODE = 64;
 var RESTART_EXIT_CODE = 75;
 var STOP_TIMEOUT_MS = 3e3;
-function detectProcessManager() {
-  return process.env.PACK_ROOT ? "wrapper" : "none";
-}
 var Lifecycle = class {
   server;
   exitFn;
-  processManager;
   adapters = [];
   stopReason = null;
   constructor(server, exitFn = (code) => process.exit(code)) {
     this.server = server;
     this.exitFn = exitFn;
-    this.processManager = detectProcessManager();
   }
   registerAdapters(adapters) {
     this.adapters = adapters;
   }
-  getRuntimeControl() {
-    return {
-      canManagedRestart: this.processManager === "wrapper",
-      processManager: this.processManager
-    };
-  }
   async requestRestart(trigger) {
     return this.requestStop("restart", trigger);
   }
@@ -5668,26 +5809,198 @@ var Lifecycle = class {
   }
 };
 
+// src/runtime/registry.ts
+import crypto from "crypto";
+import fs10 from "fs";
+import os from "os";
+import path10 from "path";
+var SKILLPACK_HOME = path10.join(os.homedir(), ".skillpack");
+var LEGACY_REGISTRY_FILE = path10.join(SKILLPACK_HOME, "registry.json");
+var REGISTRY_DIR = path10.join(SKILLPACK_HOME, "registry.d");
+var migrationChecked = false;
+function ensureHomeDir() {
+  if (!fs10.existsSync(SKILLPACK_HOME)) {
+    fs10.mkdirSync(SKILLPACK_HOME, { recursive: true });
+  }
+}
+function ensureRegistryDir() {
+  ensureHomeDir();
+  if (!fs10.existsSync(REGISTRY_DIR)) {
+    fs10.mkdirSync(REGISTRY_DIR, { recursive: true });
+  }
+}
+function canonicalizeDir(dir) {
+  const resolved = path10.resolve(dir);
+  try {
+    return fs10.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function hashDir(dir) {
+  return crypto.createHash("md5").update(canonicalizeDir(dir)).digest("hex");
+}
+function getEntryPathForCanonicalDir(dir) {
+  return path10.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
+}
+function getEntryPath(dir) {
+  ensureRegistryReady();
+  return getEntryPathForCanonicalDir(canonicalizeDir(dir));
+}
+function listEntryFiles() {
+  ensureRegistryReady();
+  return fs10.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path10.join(REGISTRY_DIR, file));
+}
+function readEntryFile(filePath) {
+  try {
+    const raw = fs10.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data?.dir !== "string" || typeof data?.name !== "string" || typeof data?.version !== "string" || typeof data?.port !== "number" || typeof data?.pid !== "number" && data?.pid !== null || data?.status !== "running" && data?.status !== "stopped") {
+      return null;
+    }
+    return {
+      dir: canonicalizeDir(data.dir),
+      name: data.name,
+      version: data.version,
+      port: data.port,
+      pid: data.pid,
+      status: data.status,
+      startedAt: data.startedAt,
+      stoppedAt: data.stoppedAt,
+      updatedAt: data.updatedAt
+    };
+  } catch {
+    return null;
+  }
+}
+function createTmpPath(entryPath) {
+  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
+  return `${entryPath}.tmp.${suffix}`;
+}
+function writeEntryFile(entry) {
+  ensureRegistryReady();
+  const normalized = {
+    ...entry,
+    dir: canonicalizeDir(entry.dir),
+    updatedAt: entry.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const entryPath = getEntryPathForCanonicalDir(normalized.dir);
+  const tmpPath = createTmpPath(entryPath);
+  fs10.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
+  fs10.renameSync(tmpPath, entryPath);
+}
+function migrateLegacyRegistryIfNeeded() {
+  if (migrationChecked) {
+    return;
+  }
+  migrationChecked = true;
+  ensureRegistryDir();
+  if (!fs10.existsSync(LEGACY_REGISTRY_FILE)) {
+    return;
+  }
+  if (listEntryFiles().length > 0) {
+    return;
+  }
+  try {
+    const raw = fs10.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    const packs = Array.isArray(data?.packs) ? data.packs : [];
+    for (const pack of packs) {
+      try {
+        writeEntryFile({
+          ...pack,
+          dir: canonicalizeDir(pack.dir),
+          updatedAt: pack.updatedAt ?? pack.stoppedAt ?? pack.startedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch {
+      }
+    }
+    fs10.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
+  } catch (err) {
+    console.warn("  [Registry] Failed to migrate legacy registry.json:", err);
+  }
+}
+function ensureRegistryReady() {
+  ensureRegistryDir();
+  migrateLegacyRegistryIfNeeded();
+}
+function readEntry(dir) {
+  ensureRegistryReady();
+  return readEntryFile(getEntryPath(dir));
+}
+function register(opts) {
+  try {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      dir: canonicalizeDir(opts.dir),
+      name: opts.name,
+      version: opts.version,
+      port: opts.port,
+      pid: process.pid,
+      status: "running",
+      startedAt: now,
+      updatedAt: now
+    };
+    writeEntryFile(entry);
+    console.log(`  [Registry] Registered "${opts.name}" (pid ${process.pid})`);
+  } catch (err) {
+    console.warn("  [Registry] Failed to register:", err);
+  }
+}
+function deregister(dir, pid) {
+  try {
+    const entry = readEntry(dir);
+    if (!entry || entry.pid !== pid) {
+      return;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    writeEntryFile({
+      ...entry,
+      pid: null,
+      status: "stopped",
+      stoppedAt: now,
+      updatedAt: now
+    });
+    console.log(`  [Registry] Deregistered "${entry.name}"`);
+  } catch (err) {
+    console.warn("  [Registry] Failed to deregister:", err);
+  }
+}
+
 // src/runtime/server.ts
-var __dirname = path11.dirname(fileURLToPath2(import.meta.url));
+var __dirname = path12.dirname(fileURLToPath2(import.meta.url));
 async function startServer(options) {
   const {
     rootDir,
     host = process.env.HOST || "127.0.0.1",
     port = Number(process.env.PORT) || 26313,
-    firstRun = true
+    daemonRun = false
   } = options;
   const dataConfig = configManager.load(rootDir);
   const apiKey = dataConfig.apiKey || "";
   const provider = dataConfig.provider || "openai";
+  const canonicalRootDir = canonicalizeDir(rootDir);
+  const packConfig = loadConfig(canonicalRootDir);
   const baseUrl = dataConfig.baseUrl?.trim() || void 0;
-  const modelId = provider === "anthropic" ? "claude-opus-4-6" : "gpt-5.4";
-  const packageRoot = path11.resolve(__dirname, "..");
-  const webDir = fs12.existsSync(path11.join(rootDir, "web")) ? path11.join(rootDir, "web") : path11.join(packageRoot, "web");
+  const modelId = SUPPORTED_PROVIDERS[provider]?.defaultModelId ?? SUPPORTED_PROVIDERS.openai.defaultModelId;
+  const packageRoot = path12.resolve(__dirname, "..");
+  const webDir = fs13.existsSync(path12.join(rootDir, "web")) ? path12.join(rootDir, "web") : path12.join(packageRoot, "web");
   const app = express();
   app.use(express.json());
   app.use(express.static(webDir));
   const server = createServer(app);
+  app.get("/api/health", (_req, res) => {
+    const address = server.address();
+    const actualPort = typeof address === "string" ? port : address?.port ?? port;
+    res.json({
+      status: "ok",
+      dir: canonicalRootDir,
+      name: packConfig.name,
+      version: packConfig.version,
+      port: actualPort,
+      pid: process.pid
+    });
+  });
   const lifecycle = new Lifecycle(server);
   const agent = new PackAgent({
     apiKey,
@@ -5782,7 +6095,17 @@ async function startServer(options) {
   Skills Pack Server`);
     console.log(`  Running at ${url}
 `);
-    if (firstRun) {
+    try {
+      register({
+        dir: canonicalRootDir,
+        name: packConfig.name,
+        version: packConfig.version,
+        port: typeof actualPort === "number" ? actualPort : port
+      });
+    } catch (err) {
+      console.warn("  [Registry] Could not register pack:", err);
+    }
+    if (!daemonRun) {
       const cmd = process.platform === "darwin" ? `open ${url}` : process.platform === "win32" ? `start ${url}` : `xdg-open ${url}`;
       exec(cmd, (err) => {
         if (err) console.warn(`  Could not open browser: ${err.message}`);
@@ -5790,9 +6113,11 @@ async function startServer(options) {
     }
   });
   process.on("SIGINT", () => {
+    deregister(canonicalRootDir, process.pid);
     void lifecycle.requestShutdown("signal");
   });
   process.on("SIGTERM", () => {
+    deregister(canonicalRootDir, process.pid);
     void lifecycle.requestShutdown("signal");
   });
   await new Promise((resolve, reject) => {
@@ -5827,23 +6152,23 @@ function findMissingSkills(workDir, config) {
   });
 }
 function copyStartTemplates2(workDir) {
-  const templateDir = path12.resolve(
+  const templateDir = path13.resolve(
     new URL("../templates", import.meta.url).pathname
   );
   for (const file of ["start.sh", "start.bat"]) {
-    const src = path12.join(templateDir, file);
-    const dest = path12.join(workDir, file);
-    if (fs13.existsSync(src)) {
-      fs13.copyFileSync(src, dest);
+    const src = path13.join(templateDir, file);
+    const dest = path13.join(workDir, file);
+    if (fs14.existsSync(src)) {
+      fs14.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs13.chmodSync(dest, 493);
+        fs14.chmodSync(dest, 493);
       }
     }
   }
 }
 async function runCommand(directory) {
-  const workDir = directory ? path12.resolve(directory) : process.cwd();
-  fs13.mkdirSync(workDir, { recursive: true });
+  const workDir = directory ? path13.resolve(directory) : process.cwd();
+  fs14.mkdirSync(workDir, { recursive: true });
   if (!configExists(workDir)) {
     console.log(chalk4.blue("\n  No skillpack.json found. Let's set one up.\n"));
     const { name, description } = await inquirer2.prompt([
@@ -5879,13 +6204,16 @@ async function runCommand(directory) {
       console.warn(chalk4.yellow(`  Warning: Some skills could not be installed: ${err}`));
     }
   }
-  await startServer({ rootDir: workDir, firstRun: true });
+  await startServer({
+    rootDir: workDir,
+    daemonRun: process.env.DAEMON_RUN === "1"
+  });
 }
 
 // src/cli.ts
-import fs14 from "fs";
+import fs15 from "fs";
 var packageJson = JSON.parse(
-  fs14.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs15.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command();
 program.name("skillpack").description("Assemble, package, and run Agent Skills packs").version(packageJson.version);