@plosson/agentio 0.1.16 → 0.1.18

package/README.md

@@ -141,6 +141,29 @@ agentio provides a plugin for [Claude Code](https://claude.com/claude-code) with
 
 Once installed, Claude Code can use the agentio CLI skills to help you manage emails, send Telegram messages, and more.
 
+### Install Skills Directly
+
+You can also install skills directly without the plugin system:
+
+```bash
+# List available skills
+agentio skill list
+
+# Install all skills to current directory
+agentio skill install
+
+# Install a specific skill
+agentio skill install agentio-gmail
+
+# Install to a specific directory
+agentio skill install -d ~/myproject
+
+# Skip confirmation prompts
+agentio skill install -y
+```
+
+Skills are installed to `.claude/skills/` in the target directory.
+
 ## Design
 
 agentio is designed for LLM consumption:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "CLI for LLM agents to interact with communication and tracking services",
   "type": "module",
   "license": "MIT",
@@ -47,7 +47,6 @@
   },
   "dependencies": {
     "commander": "^14.0.2",
-    "googleapis": "^169.0.0",
-    "playwright-core": "^1.57.0"
+    "googleapis": "^169.0.0"
   }
 }

package/src/commands/gmail.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import { basename, join } from 'path';
+import { tmpdir } from 'os';
 import { google } from 'googleapis';
 import { getValidTokens, createGoogleAuth } from '../auth/token-manager';
 import { setCredentials, removeCredentials, getCredentials } from '../auth/token-store';
@@ -19,6 +20,53 @@ function escapeHtml(text: string): string {
     .replace(/"/g, '"');
 }
 
+function findChromePath(): string | null {
+  const platform = process.platform;
+
+  const paths: string[] = [];
+
+  if (platform === 'darwin') {
+    paths.push(
+      '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+      '/Applications/Chromium.app/Contents/MacOS/Chromium',
+      '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+      '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+    );
+  } else if (platform === 'linux') {
+    paths.push(
+      '/usr/bin/google-chrome',
+      '/usr/bin/google-chrome-stable',
+      '/usr/bin/chromium',
+      '/usr/bin/chromium-browser',
+      '/snap/bin/chromium',
+      '/usr/bin/microsoft-edge',
+      '/usr/bin/brave-browser',
+    );
+  } else if (platform === 'win32') {
+    const programFiles = process.env['PROGRAMFILES'] || 'C:\\Program Files';
+    const programFilesX86 = process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)';
+    const localAppData = process.env['LOCALAPPDATA'] || '';
+
+    paths.push(
+      `${programFiles}\\Google\\Chrome\\Application\\chrome.exe`,
+      `${programFilesX86}\\Google\\Chrome\\Application\\chrome.exe`,
+      `${localAppData}\\Google\\Chrome\\Application\\chrome.exe`,
+      `${programFiles}\\Microsoft\\Edge\\Application\\msedge.exe`,
+      `${programFilesX86}\\Microsoft\\Edge\\Application\\msedge.exe`,
+      `${programFiles}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
+      `${localAppData}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
+    );
+  }
+
+  for (const p of paths) {
+    if (Bun.file(p).size > 0) {
+      return p;
+    }
+  }
+
+  return null;
+}
+
 async function getGmailClient(profileName?: string): Promise<{ client: GmailClient; profile: string }> {
   const { tokens, profile } = await getValidTokens('gmail', profileName);
   const auth = createGoogleAuth(tokens);
@@ -323,25 +371,47 @@ ${emailHeader}
 </html>`;
         }
 
-        // Lazy load playwright-core to avoid bundling issues
-        const { chromium } = await import('playwright-core');
-
-        // Launch browser and generate PDF
-        console.error('Launching browser...');
-        const browser = await chromium.launch({
-          channel: 'chrome', // Use system Chrome
-        });
+        // Find Chrome browser
+        const chromePath = findChromePath();
+        if (!chromePath) {
+          throw new CliError(
+            'NOT_FOUND',
+            'Chrome/Chromium not found',
+            'Install Google Chrome, Chromium, or Microsoft Edge'
+          );
+        }
 
-        const page = await browser.newPage();
-        await page.setContent(html, { waitUntil: 'networkidle' });
-        await page.pdf({
-          path: options.output,
-          format: 'A4',
-          margin: { top: '1cm', right: '1cm', bottom: '1cm', left: '1cm' },
-        });
+        // Write HTML to temp file
+        const tempHtml = join(tmpdir(), `agentio-email-${Date.now()}.html`);
+        await Bun.write(tempHtml, html);
+
+        // Resolve output path to absolute
+        const outputPath = options.output.startsWith('/')
+          ? options.output
+          : join(process.cwd(), options.output);
+
+        try {
+          // Run Chrome in headless mode to generate PDF
+          console.error('Generating PDF...');
+          const result = Bun.spawnSync([
+            chromePath,
+            '--headless=new',
+            '--disable-gpu',
+            '--no-pdf-header-footer',
+            `--print-to-pdf=${outputPath}`,
+            tempHtml,
+          ]);
+
+          if (result.exitCode !== 0) {
+            const stderr = result.stderr.toString();
+            throw new CliError('API_ERROR', `Chrome failed: ${stderr}`);
+          }
 
-        await browser.close();
-        console.log(`Exported to ${options.output}`);
+          console.log(`Exported to ${options.output}`);
+        } finally {
+          // Clean up temp file
+          await Bun.file(tempHtml).unlink();
+        }
       } catch (error) {
         handleError(error);
       }

package/src/commands/skill.ts

@@ -0,0 +1,204 @@
+import { Command } from 'commander';
+import { createInterface } from 'readline';
+import { CliError, handleError } from '../utils/errors';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const GITHUB_REPO = 'plosson/agentio';
+const SKILLS_PATH = 'claude/skills';
+
+interface GitHubContent {
+  name: string;
+  path: string;
+  type: 'file' | 'dir';
+  download_url: string | null;
+}
+
+function prompt(question: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function fetchGitHubContents(repoPath: string): Promise<GitHubContent[]> {
+  const url = `https://api.github.com/repos/${GITHUB_REPO}/contents/${repoPath}`;
+  const response = await fetch(url, {
+    headers: {
+      'Accept': 'application/vnd.github.v3+json',
+      'User-Agent': 'agentio-skill-manager',
+    },
+  });
+
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new CliError('NOT_FOUND', `Path not found: ${repoPath}`);
+    }
+    throw new CliError('API_ERROR', `GitHub API error: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+async function fetchFileContent(downloadUrl: string): Promise<string> {
+  const response = await fetch(downloadUrl, {
+    headers: {
+      'User-Agent': 'agentio-skill-manager',
+    },
+  });
+
+  if (!response.ok) {
+    throw new CliError('API_ERROR', `Failed to download file: ${response.statusText}`);
+  }
+
+  return response.text();
+}
+
+async function listAvailableSkills(): Promise<string[]> {
+  const contents = await fetchGitHubContents(SKILLS_PATH);
+  return contents
+    .filter((item) => item.type === 'dir')
+    .map((item) => item.name);
+}
+
+async function downloadSkillFolder(
+  skillName: string,
+  targetDir: string
+): Promise<void> {
+  const skillPath = `${SKILLS_PATH}/${skillName}`;
+  const contents = await fetchGitHubContents(skillPath);
+
+  // Create target directory
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  for (const item of contents) {
+    const targetPath = path.join(targetDir, item.name);
+
+    if (item.type === 'file' && item.download_url) {
+      const content = await fetchFileContent(item.download_url);
+      fs.writeFileSync(targetPath, content);
+    } else if (item.type === 'dir') {
+      // Recursively download subdirectories
+      await downloadSkillFolder(`${skillName}/${item.name}`, targetPath);
+    }
+  }
+}
+
+async function installSkill(
+  skillName: string,
+  baseDir: string,
+  skipPrompt: boolean
+): Promise<boolean> {
+  const targetDir = path.join(baseDir, '.claude', 'skills', skillName);
+
+  // Check if skill already exists
+  if (fs.existsSync(targetDir)) {
+    if (!skipPrompt) {
+      const answer = await prompt(
+        `Skill '${skillName}' already exists at ${targetDir}. Update? [y/N] `
+      );
+      if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+        console.error(`Skipping '${skillName}'`);
+        return false;
+      }
+    }
+    // Remove existing skill directory before updating
+    fs.rmSync(targetDir, { recursive: true });
+  }
+
+  console.error(`Installing skill: ${skillName}...`);
+  await downloadSkillFolder(skillName, targetDir);
+  console.log(`Installed: ${skillName} -> ${targetDir}`);
+  return true;
+}
+
+export function registerSkillCommands(program: Command): void {
+  const skill = program
+    .command('skill')
+    .description('Manage Claude Code skills');
+
+  skill
+    .command('list')
+    .description('List available skills from the repository')
+    .action(async () => {
+      try {
+        console.error('Fetching available skills...');
+        const skills = await listAvailableSkills();
+
+        if (skills.length === 0) {
+          console.log('No skills found in repository');
+          return;
+        }
+
+        console.log('Available skills:');
+        for (const name of skills) {
+          console.log(`  ${name}`);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  skill
+    .command('install')
+    .description('Install skills from the repository')
+    .argument('[skill-name]', 'Name of the skill to install (omit to install all)')
+    .option('-d, --dir <path>', 'Target directory (default: current directory)')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .action(async (skillName, options) => {
+      try {
+        const baseDir = options.dir ? path.resolve(options.dir) : process.cwd();
+
+        // Verify base directory exists
+        if (!fs.existsSync(baseDir)) {
+          throw new CliError(
+            'INVALID_PARAMS',
+            `Directory does not exist: ${baseDir}`
+          );
+        }
+
+        console.error(`Target: ${path.join(baseDir, '.claude', 'skills')}`);
+
+        if (skillName) {
+          // Install specific skill
+          const skills = await listAvailableSkills();
+          if (!skills.includes(skillName)) {
+            throw new CliError(
+              'NOT_FOUND',
+              `Skill '${skillName}' not found`,
+              `Available skills: ${skills.join(', ')}`
+            );
+          }
+          await installSkill(skillName, baseDir, options.yes);
+        } else {
+          // Install all skills
+          console.error('Fetching available skills...');
+          const skills = await listAvailableSkills();
+
+          if (skills.length === 0) {
+            console.log('No skills found in repository');
+            return;
+          }
+
+          console.error(`Found ${skills.length} skill(s)`);
+
+          let installed = 0;
+          for (const name of skills) {
+            const success = await installSkill(name, baseDir, options.yes);
+            if (success) installed++;
+          }
+
+          console.log(`\nInstalled ${installed} of ${skills.length} skill(s)`);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/index.ts

@@ -7,6 +7,7 @@ import { registerJiraCommands } from './commands/jira';
 import { registerSlackCommands } from './commands/slack';
 import { registerUpdateCommand } from './commands/update';
 import { registerConfigCommands } from './commands/config';
+import { registerSkillCommands } from './commands/skill';
 
 declare const BUILD_VERSION: string | undefined;
 
@@ -32,5 +33,6 @@ registerJiraCommands(program);
 registerSlackCommands(program);
 registerUpdateCommand(program);
 registerConfigCommands(program);
+registerSkillCommands(program);
 
 program.parse();