@chakresh/kresh 0.1.2 → 0.1.4

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@chakresh/kresh",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "bin": {
     "kresh": "./src/index.js"
   },
   "type": "module",
   "dependencies": {
-    "@chakresh/kresh": "^0.1.1",
     "axios": "^1.6.8",
     "chalk": "^5.3.0",
     "commander": "^11.1.0",

package/src/commands/install.js

@@ -8,7 +8,9 @@ import { logger } from '../utils/logger.js';
 /**
  * Installs a skill from the registry locally.
  */
-export async function installSkill(skillSlug) {
+import { cliAuthFlow, getToken } from '../services/auth.js';
+
+export async function installSkill(skillSlug, isRetry = false) {
   const spinner = ora(`Fetching skill "${skillSlug}"...`).start();
   try {
     const response = await api.get(`/api/skills/${skillSlug}`);
@@ -20,15 +22,32 @@ export async function installSkill(skillSlug) {
     spinner.succeed(`Successfully installed ${logger.bold(metadata.name)} (v${metadata.currentVersion}) by @${metadata.ownerUsername}`);
     logger.info(`Saved to: ${logger.bold(savedDir)}`);
   } catch (error) {
-    spinner.fail(`Installation failed for "${skillSlug}"`);
-    if (error.response) {
-      if (error.response.status === 404) {
-        logger.error(`Skill "${skillSlug}" was not found in the registry.`);
+    spinner.stop();
+    if (error.response && error.response.status === 404 && !isRetry) {
+      // It might be a private skill, let's try authenticating
+      logger.info(`Skill "${skillSlug}" not found publicly. This might be a private skill.`);
+      
+      const hasToken = getToken();
+      if (!hasToken) {
+        logger.info('Attempting to authenticate via browser to access private skills...');
+        try {
+          await cliAuthFlow();
+          // Retry the installation now that we have a token
+          logger.info('Authentication successful. Retrying download...');
+          return await installSkill(skillSlug, true);
+        } catch (authErr) {
+          logger.error('Authentication failed: ' + authErr.message);
+        }
       } else {
-        logger.error(`Registry error: ${error.response.data?.error || error.response.statusText}`);
+        logger.error(`Skill "${skillSlug}" was not found in the registry, even with your authenticated session.`);
       }
     } else {
-      logger.error(`Connection error: ${error.message}`);
+      spinner.fail(`Installation failed for "${skillSlug}"`);
+      if (error.response) {
+        logger.error(`Registry error: ${error.response.data?.error || error.response.statusText}`);
+      } else {
+        logger.error(`Connection error: ${error.message}`);
+      }
     }
   }
 }

package/src/services/api.js

@@ -1,6 +1,7 @@
 import axios from 'axios';
+import { getToken } from './auth.js';
 
-const baseURL = process.env.KRESH_API_URL || 'https://kresh.vercel.app';
+const baseURL = process.env.KRESH_API_URL || 'http://localhost:3000'; // Assume localhost for local testing
 
 export const api = axios.create({
   baseURL,
@@ -10,3 +11,12 @@ export const api = axios.create({
     'Content-Type': 'application/json'
   }
 });
+
+api.interceptors.request.use((config) => {
+  const token = getToken();
+  if (token) {
+    config.headers.Authorization = `Bearer ${token}`;
+  }
+  return config;
+});
+

package/src/services/auth.js

@@ -0,0 +1,96 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { exec } from 'child_process';
+import { logger } from '../utils/logger.js';
+import ora from 'ora';
+
+const KRESH_DIR = path.join(os.homedir(), '.kresh');
+const CONFIG_FILE = path.join(KRESH_DIR, 'config.json');
+
+export function getToken() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+      return config.token || null;
+    }
+  } catch (err) {
+    // ignore
+  }
+  return null;
+}
+
+export function setToken(token) {
+  try {
+    if (!fs.existsSync(KRESH_DIR)) {
+      fs.mkdirSync(KRESH_DIR, { recursive: true });
+    }
+    const config = fs.existsSync(CONFIG_FILE) ? JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8')) : {};
+    config.token = token;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+  } catch (err) {
+    logger.error('Failed to save config: ' + err.message);
+  }
+}
+
+function openBrowser(url) {
+  const startCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+  exec(`${startCmd} "${url}"`, (err) => {
+    if (err) {
+      logger.warn(`Could not open browser automatically. Please visit: ${url}`);
+    }
+  });
+}
+
+export async function cliAuthFlow() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://${req.headers.host}`);
+      if (url.pathname === '/callback') {
+        const token = url.searchParams.get('token');
+        if (token) {
+          res.writeHead(200, { 'Content-Type': 'text/html' });
+          res.end(`
+            <html>
+              <head><title>Kresh CLI Authenticated</title></head>
+              <body style="font-family: monospace; padding: 2rem; text-align: center; background: #000; color: #fff;">
+                <h2 style="color: #4ade80;">Success!</h2>
+                <p>The Kresh CLI has been authenticated. You can close this window and return to your terminal.</p>
+              </body>
+            </html>
+          `);
+          
+          setToken(token);
+          
+          setTimeout(() => {
+            server.close();
+            resolve(token);
+          }, 500);
+        } else {
+          res.writeHead(400, { 'Content-Type': 'text/plain' });
+          res.end('Missing token in callback.');
+          server.close();
+          reject(new Error('Missing token'));
+        }
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+
+    server.listen(0, '127.0.0.1', () => {
+      const port = server.address().port;
+      const baseUrl = process.env.KRESH_API_URL || 'https://kresh.vercel.app';
+      const authUrl = `${baseUrl}/cli/auth?port=${port}`;
+      
+      const spinner = ora('Opening browser for authentication...').start();
+      openBrowser(authUrl);
+      spinner.succeed(`Waiting for authentication... (if browser doesn't open, visit ${authUrl})`);
+    });
+    
+    server.on('error', (err) => {
+      reject(err);
+    });
+  });
+}

package/src/services/filesystem.js

@@ -2,13 +2,59 @@ import fs from 'fs/promises';
 import path from 'path';
 
 /**
- * Writes the SKILL.md and metadata.json files directly in a folder named after the skill's slug inside the skills folder.
+ * Helper to find the workspace or project root directory by scanning up.
+ */
+async function getWorkspaceRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  while (true) {
+    try {
+      const hasPackageJson = await fs.access(path.join(currentDir, 'package.json')).then(() => true).catch(() => false);
+      const isKreshRoot = await fs.access(path.join(currentDir, 'next.config.mjs')).then(() => true).catch(() => false);
+      
+      if (hasPackageJson && isKreshRoot) {
+        return currentDir;
+      }
+    } catch (e) {
+      // Ignore
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  
+  // Secondary check: look for any package.json up the tree
+  currentDir = startDir;
+  while (true) {
+    try {
+      const hasPackageJson = await fs.access(path.join(currentDir, 'package.json')).then(() => true).catch(() => false);
+      if (hasPackageJson) {
+        return currentDir;
+      }
+    } catch (e) {
+      // Ignore
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+
+  return startDir;
+}
+
+/**
+ * Writes the SKILL.md and metadata.json files directly in a folder named after the skill's slug (excluding @owner scope folder) inside the skills folder.
  */
 export async function writeLocalSkill(slug, skillContent, metadata) {
   try {
-    // Sanitize folder name, use slug
-    const folderName = slug || metadata.slug;
-    const targetDir = path.join(process.cwd(), 'skills', folderName);
+    const rootDir = await getWorkspaceRoot();
+    const folderName = (slug || metadata.slug).split('/').pop();
+    const targetDir = path.join(rootDir, 'skills', folderName);
+    
     await fs.mkdir(targetDir, { recursive: true });
     await fs.writeFile(path.join(targetDir, 'SKILL.md'), skillContent, 'utf8');
     await fs.writeFile(path.join(targetDir, 'metadata.json'), JSON.stringify(metadata, null, 2), 'utf8');
@@ -24,11 +70,21 @@ export async function writeLocalSkill(slug, skillContent, metadata) {
  */
 export async function readLocalSkillMetadata(slug) {
   try {
-    const metadataPath = path.join(process.cwd(), 'skills', slug, 'metadata.json');
+    const rootDir = await getWorkspaceRoot();
+    const folderName = slug.split('/').pop();
+    const metadataPath = path.join(rootDir, 'skills', folderName, 'metadata.json');
     const data = await fs.readFile(metadataPath, 'utf8');
     return JSON.parse(data);
   } catch (error) {
-    return null;
+    // Also try legacy path for backwards compatibility
+    try {
+      const rootDir = await getWorkspaceRoot();
+      const legacyPath = path.join(rootDir, 'skills', slug, 'metadata.json');
+      const data = await fs.readFile(legacyPath, 'utf8');
+      return JSON.parse(data);
+    } catch (e) {
+      return null;
+    }
   }
 }
 
@@ -37,20 +93,26 @@ export async function readLocalSkillMetadata(slug) {
  */
 export async function removeLocalSkill(slug) {
   try {
-    const targetDir = path.join(process.cwd(), 'skills', slug);
+    const rootDir = await getWorkspaceRoot();
+    const folderName = slug.split('/').pop();
+    const targetDir = path.join(rootDir, 'skills', folderName);
     await fs.rm(targetDir, { recursive: true, force: true });
     
+    // Also clean up legacy directory if it exists
+    const legacyDir = path.join(rootDir, 'skills', slug);
+    await fs.rm(legacyDir, { recursive: true, force: true });
+    
     // Clean up empty parent directory (e.g. @username) if it becomes empty
     if (slug.includes('/')) {
       const parts = slug.split('/');
-      const parentDir = path.join(process.cwd(), 'skills', parts[0]);
+      const parentDir = path.join(rootDir, 'skills', parts[0]);
       try {
         const files = await fs.readdir(parentDir);
         if (files.length === 0) {
           await fs.rmdir(parentDir);
         }
       } catch (e) {
-        // Ignore errors if directory is not empty or doesn't exist
+        // Ignore
       }
     }
     return true;
@@ -65,7 +127,8 @@ export async function removeLocalSkill(slug) {
  */
 export async function listLocalSkills() {
   try {
-    const skillsDir = path.join(process.cwd(), 'skills');
+    const rootDir = await getWorkspaceRoot();
+    const skillsDir = path.join(rootDir, 'skills');
     let entries = [];
     try {
       entries = await fs.readdir(skillsDir, { withFileTypes: true });
@@ -78,7 +141,7 @@ export async function listLocalSkills() {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (entry.name.startsWith('@')) {
-          // It's a user scope directory, scan subdirectories inside it
+          // Legacy support: It's a user scope directory, scan subdirectories inside it
           const scopeDir = path.join(skillsDir, entry.name);
           let subEntries = [];
           try {
@@ -103,16 +166,22 @@ export async function listLocalSkills() {
             }
           }
         } else {
-          // Standard/global skill directory
-          const metadata = await readLocalSkillMetadata(entry.name);
-          if (metadata) {
-            skills.push({
-              slug: metadata.slug || entry.name,
-              installed: true,
-              version: metadata.version || metadata.currentVersion || 'unknown',
-              name: metadata.name || 'unknown',
-              description: metadata.description || ''
-            });
+          // New format: Directly under skills/
+          try {
+            const metadataPath = path.join(skillsDir, entry.name, 'metadata.json');
+            const data = await fs.readFile(metadataPath, 'utf8');
+            const metadata = JSON.parse(data);
+            if (metadata) {
+              skills.push({
+                slug: metadata.slug || entry.name,
+                installed: true,
+                version: metadata.version || metadata.currentVersion || 'unknown',
+                name: metadata.name || 'unknown',
+                description: metadata.description || ''
+              });
+            }
+          } catch (e) {
+            // Ignore if metadata is invalid/missing
           }
         }
       }