@42ailab/42plugin 0.1.0-beta.0

package/src/commands/search.ts

@@ -0,0 +1,87 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { api } from '../services/api';
+
+interface SearchOptions {
+  type?: string;
+  limit?: string;
+  json?: boolean;
+}
+
+export const searchCommand = new Command('search')
+  .description('搜索插件')
+  .argument('<query>', '搜索关键词')
+  .option('--type <type>', '筛选类型: skill | agent | command | hook | list')
+  .option('--limit <n>', '结果数量限制', '20')
+  .option('--json', 'JSON 格式输出')
+  .action(async (query: string, options: SearchOptions) => {
+    await search(query, options);
+  });
+
+async function search(query: string, options: SearchOptions) {
+  try {
+    const results = await api.search(query, {
+      type: options.type,
+      per_page: Number(options.limit) || 20,
+    });
+
+    if (options.json) {
+      console.log(JSON.stringify(results, null, 2));
+      return;
+    }
+
+    // Display capability results
+    if (results.capabilities.length > 0) {
+      console.log();
+      console.log(chalk.bold('能力:'));
+      console.log();
+
+      for (const cap of results.capabilities) {
+        const typeColor = getTypeColor(cap.type);
+        // Use short_name (author/slug) for display, making it easy to copy for install
+        const displayName = cap.short_name;
+        console.log(`  ${typeColor(cap.type.padEnd(7))} ${chalk.cyan(displayName)}`);
+        if (cap.description) {
+          console.log(`          ${chalk.gray(truncate(cap.description, 60))}`);
+        }
+        console.log(`          ${chalk.gray(`下载: ${cap.downloads}`)}  ${chalk.dim(`安装: 42plugin install ${displayName}`)}`);
+        console.log();
+      }
+    }
+
+    // Display list results
+    if (results.lists.length > 0) {
+      console.log();
+      console.log(chalk.bold('列表:'));
+      console.log();
+
+      for (const list of results.lists) {
+        console.log(`  ${chalk.magenta('list')}    ${chalk.cyan(list.full_name)}`);
+        console.log(`          ${list.name}`);
+        console.log(`          ${chalk.gray(`${list.capability_count} 个能力 · 下载: ${list.downloads}`)}`);
+        console.log();
+      }
+    }
+
+    if (results.capabilities.length === 0 && results.lists.length === 0) {
+      console.log(chalk.yellow('未找到结果'));
+    }
+  } catch (error) {
+    console.error(chalk.red(`搜索失败: ${(error as Error).message}`));
+    process.exit(1);
+  }
+}
+
+function getTypeColor(type: string): (text: string) => string {
+  const colors: Record<string, (text: string) => string> = {
+    skill: chalk.blue,
+    agent: chalk.green,
+    command: chalk.yellow,
+    hook: chalk.magenta,
+  };
+  return colors[type] || chalk.white;
+}
+
+function truncate(str: string, len: number): string {
+  return str.length > len ? str.slice(0, len - 3) + '...' : str;
+}

package/src/commands/uninstall.ts

@@ -0,0 +1,58 @@
+import { Command } from 'commander';
+import fs from 'fs/promises';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getProject, removeProjectPlugin } from '../services/project';
+import { removeFromCache } from '../services/cache';
+
+interface UninstallOptions {
+  purge?: boolean;
+}
+
+export const uninstallCommand = new Command('uninstall')
+  .description('卸载插件')
+  .argument('<plugin>', '插件标识符')
+  .option('--purge', '同时删除缓存')
+  .action(async (plugin: string, options: UninstallOptions) => {
+    await uninstall(plugin, options);
+  });
+
+async function uninstall(plugin: string, options: UninstallOptions) {
+  const spinner = ora(`卸载 ${plugin}...`).start();
+
+  try {
+    const projectPath = process.cwd();
+    const project = await getProject(projectPath);
+
+    if (!project) {
+      spinner.fail('当前目录不是 42plugin 项目');
+      return;
+    }
+
+    // Get install record
+    const record = await removeProjectPlugin(project.id, plugin);
+
+    if (!record) {
+      spinner.fail(`未找到已安装的插件: ${plugin}`);
+      return;
+    }
+
+    // Remove link (normalize path by removing trailing slash)
+    try {
+      const linkPath = record.link_path.replace(/\/+$/, '');
+      await fs.rm(linkPath, { recursive: true, force: true });
+    } catch {
+      // Ignore deletion errors
+    }
+
+    // If --purge specified, also remove from cache
+    if (options.purge) {
+      await removeFromCache(plugin, record.version);
+    }
+
+    spinner.succeed(`${chalk.green('已卸载')} ${plugin}`);
+  } catch (error) {
+    spinner.fail(`卸载失败: ${(error as Error).message}`);
+    process.exit(1);
+  }
+}

package/src/commands/version.ts

@@ -0,0 +1,20 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+export const versionCommand = new Command('version')
+  .description('显示版本信息')
+  .action(() => {
+    // Try to read version from package.json
+    try {
+      // Get the directory of the current module
+      const __dirname = path.dirname(fileURLToPath(import.meta.url));
+      const pkgPath = path.resolve(__dirname, '../../package.json');
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      console.log(`42plugin CLI v${pkg.version}`);
+    } catch {
+      // Fallback if package.json is not readable
+      console.log('42plugin CLI v0.1.0');
+    }
+  });

package/src/config.ts

@@ -0,0 +1,44 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+
+let dataDir: string | null = null;
+
+export function getDataDir(): string {
+  if (dataDir) return dataDir;
+
+  if (process.platform === 'win32') {
+    dataDir = path.join(process.env.APPDATA || os.homedir(), '42plugin');
+  } else {
+    dataDir = path.join(os.homedir(), '.42plugin');
+  }
+
+  // Ensure directory exists
+  if (!fs.existsSync(dataDir)) {
+    fs.mkdirSync(dataDir, { recursive: true });
+  }
+
+  return dataDir;
+}
+
+export function getCacheDir(): string {
+  const cacheDir = path.join(getDataDir(), 'cache');
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true });
+  }
+  return cacheDir;
+}
+
+export function getDbPath(): string {
+  return path.join(getDataDir(), 'local.db');
+}
+
+export function getSecretsPath(): string {
+  return path.join(getDataDir(), 'secrets.json');
+}
+
+export const config = {
+  apiBase: process.env.API_BASE || 'https://api.42plugin.com',
+  cdnBase: process.env.CDN_BASE || 'https://cdn.42plugin.com',
+  debug: process.env.DEBUG === 'true',
+};

package/src/db/client.ts

@@ -0,0 +1,180 @@
+import { createClient as createLibsqlClient } from '@libsql/client';
+import { Pool } from 'pg';
+import { getDbPath } from '../config';
+
+type Query = string | { sql: string; args?: unknown[] };
+
+export interface DbClient {
+  execute(query: Query): Promise<{ rows: unknown[] }>;
+  close(): Promise<void> | void;
+}
+
+let client: DbClient | null = null;
+
+function normalizeQuery(query: Query): { sql: string; args: unknown[] } {
+  if (typeof query === 'string') {
+    return { sql: query, args: [] };
+  }
+  return {
+    sql: query.sql,
+    args: query.args || [],
+  };
+}
+
+function convertParamsToPg(sql: string): string {
+  let paramIndex = 0;
+  return sql.replace(/\?/g, () => {
+    paramIndex += 1;
+    return `$${paramIndex}`;
+  });
+}
+
+function createSqliteClient(): DbClient {
+  const sqliteClient = createLibsqlClient({
+    url: `file:${getDbPath()}`,
+  });
+
+  return {
+    execute: (query) => sqliteClient.execute(query as any),
+    close: () => sqliteClient.close(),
+  };
+}
+
+function createPostgresClient(): DbClient {
+  const connectionString =
+    process.env.CLI_DATABASE_URL ||
+    process.env.LOCAL_DATABASE_URL ||
+    process.env.DATABASE_URL ||
+    process.env.POSTGRES_URL;
+
+  if (!connectionString) {
+    throw new Error(
+      'Postgres connection string not provided. Set CLI_DATABASE_URL, LOCAL_DATABASE_URL, or DATABASE_URL.'
+    );
+  }
+
+  const pool = new Pool({ connectionString });
+
+  return {
+    async execute(query) {
+      const { sql, args } = normalizeQuery(query);
+      const text = convertParamsToPg(sql);
+      const res = await pool.query(text, args);
+      return { rows: res.rows };
+    },
+    async close() {
+      await pool.end();
+    },
+  };
+}
+
+function createDbClient(): DbClient {
+  const driver = (process.env.CLI_DB_DRIVER || process.env.DB_DRIVER || 'sqlite').toLowerCase();
+  if (driver === 'postgres' || driver === 'postgresql' || driver === 'pg') {
+    return createPostgresClient();
+  }
+  return createSqliteClient();
+}
+
+export function getDb(): DbClient {
+  if (!client) {
+    client = createDbClient();
+  }
+  return client;
+}
+
+// Future extension: Support remote sync (Turso); fallback to current driver for Postgres
+export function getDbWithSync(authToken: string): DbClient {
+  const driver = (process.env.CLI_DB_DRIVER || process.env.DB_DRIVER || 'sqlite').toLowerCase();
+
+  if (driver === 'postgres' || driver === 'postgresql' || driver === 'pg') {
+    return getDb();
+  }
+
+  const sqliteClient = createLibsqlClient({
+    url: `file:${getDbPath()}`,
+    syncUrl: process.env.TURSO_DATABASE_URL,
+    authToken,
+    syncInterval: 60, // Sync every 60 seconds
+  });
+
+  return {
+    execute: (query) => sqliteClient.execute(query as any),
+    close: () => sqliteClient.close(),
+  };
+}
+
+export async function initDb(): Promise<void> {
+  const db = getDb();
+
+  // Create projects table
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id              TEXT PRIMARY KEY,
+      path            TEXT NOT NULL UNIQUE,
+      name            TEXT,
+      registered_at   TEXT NOT NULL,
+      last_used_at    TEXT NOT NULL
+    )
+  `);
+
+  await db.execute(`
+    CREATE INDEX IF NOT EXISTS idx_projects_path ON projects(path)
+  `);
+
+  // Create plugin_cache table
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS plugin_cache (
+      id              TEXT PRIMARY KEY,
+      full_name       TEXT NOT NULL,
+      type            TEXT NOT NULL,
+      version         TEXT NOT NULL,
+      cache_path      TEXT NOT NULL,
+      checksum        TEXT NOT NULL,
+      size_bytes      INTEGER,
+      downloaded_at   TEXT NOT NULL,
+      UNIQUE(full_name, version)
+    )
+  `);
+
+  await db.execute(`
+    CREATE INDEX IF NOT EXISTS idx_cache_name ON plugin_cache(full_name)
+  `);
+
+  // Create project_plugins table
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS project_plugins (
+      id              TEXT PRIMARY KEY,
+      project_id      TEXT NOT NULL,
+      full_name       TEXT NOT NULL,
+      type            TEXT NOT NULL,
+      version         TEXT NOT NULL,
+      cache_path      TEXT NOT NULL,
+      link_path       TEXT NOT NULL,
+      installed_at    TEXT NOT NULL,
+      source          TEXT DEFAULT 'direct',
+      source_list     TEXT,
+      UNIQUE(project_id, full_name),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    )
+  `);
+
+  await db.execute(`
+    CREATE INDEX IF NOT EXISTS idx_pp_project ON project_plugins(project_id)
+  `);
+
+  // Create config table
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS config (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+}
+
+export async function closeDb(): Promise<void> {
+  if (client) {
+    await client.close();
+    client = null;
+  }
+}

package/src/index.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+
+import { program } from './cli';
+import { initDb } from './db/client';
+import { api } from './services/api';
+import { CliError } from './utils/errors';
+import chalk from 'chalk';
+
+async function main() {
+  try {
+    // Initialize database
+    await initDb();
+
+    // Initialize API client
+    await api.init();
+
+    // Parse and execute command
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof CliError) {
+      console.error(chalk.red(`错误: ${error.message}`));
+      process.exit(error.exitCode);
+    }
+
+    // Unknown error
+    if (process.env.DEBUG) {
+      console.error(error);
+    } else {
+      console.error(chalk.red(`发生错误: ${(error as Error).message}`));
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/src/services/api.ts

@@ -0,0 +1,128 @@
+import { loadSecrets } from './auth';
+import { config } from '../config';
+import type {
+  AuthStartResponse,
+  AuthPollResponse,
+  UserProfile,
+  CapabilityDownload,
+  PluginDetail,
+  ListDownload,
+  SearchResult,
+  SearchOptions,
+} from '../types/api';
+
+class ApiClient {
+  private accessToken: string | null = null;
+  private initialized = false;
+
+  async init(): Promise<void> {
+    if (this.initialized) return;
+    const secrets = await loadSecrets();
+    this.accessToken = secrets?.access_token || null;
+    this.initialized = true;
+  }
+
+  isAuthenticated(): boolean {
+    return !!this.accessToken;
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    options: {
+      body?: unknown;
+      auth?: boolean;
+    } = {}
+  ): Promise<T> {
+    if (!this.initialized) {
+      await this.init();
+    }
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+
+    if (options.auth !== false && this.accessToken) {
+      headers['Authorization'] = `Bearer ${this.accessToken}`;
+    }
+
+    const response = await fetch(`${config.apiBase}${path}`, {
+      method,
+      headers,
+      body: method === 'POST' || method === 'PUT' || method === 'PATCH'
+        ? JSON.stringify(options.body ?? {})
+        : undefined,
+    });
+
+    const data = await response.json() as { data?: T; error?: { message: string } };
+
+    if (!response.ok) {
+      throw new Error(data.error?.message || 'API request failed');
+    }
+
+    return data.data as T;
+  }
+
+  // Auth
+  async startAuth(): Promise<AuthStartResponse> {
+    return this.request('POST', '/v1/auth/cli/start', { auth: false });
+  }
+
+  async pollAuth(code: string): Promise<AuthPollResponse> {
+    return this.request('GET', `/v1/auth/cli/poll?code=${code}`, { auth: false });
+  }
+
+  async getMe(): Promise<UserProfile> {
+    return this.request('GET', '/v1/auth/me');
+  }
+
+  // Capabilities
+  async getCapabilityDownload(fullName: string): Promise<CapabilityDownload> {
+    const encoded = encodeURIComponent(fullName);
+    return this.request('GET', `/v1/capabilities/by-name/download?full_name=${encoded}`);
+  }
+
+  async getCapabilityDownloadBySlug(author: string, slug: string): Promise<CapabilityDownload> {
+    return this.request('GET', `/v1/capabilities/${author}/${slug}/download`);
+  }
+
+  // Plugins
+  async getPluginByName(fullName: string): Promise<PluginDetail> {
+    const encoded = encodeURIComponent(fullName);
+    return this.request('GET', `/v1/plugins/by-name?full_name=${encoded}`);
+  }
+
+  async getPluginDownload(user: string, plugin: string, version?: string): Promise<CapabilityDownload> {
+    let path = `/v1/plugins/${user}/${plugin}/download`;
+    if (version) {
+      path += `?version=${version}`;
+    }
+    return this.request('GET', path);
+  }
+
+  // Lists
+  async getListDownload(username: string, slugOrId: string): Promise<ListDownload> {
+    return this.request('GET', `/v1/lists/${username}/list/${slugOrId}/download`);
+  }
+
+  // Search
+  async search(query: string, options?: SearchOptions): Promise<SearchResult> {
+    const params = new URLSearchParams({ q: query });
+    if (options?.type) params.set('type', options.type);
+    if (options?.per_page) params.set('per_page', String(options.per_page));
+    return this.request('GET', `/v1/search?${params}`);
+  }
+
+  // Reset token (for logout)
+  resetToken(): void {
+    this.accessToken = null;
+    this.initialized = false;
+  }
+
+  // Set token (for login)
+  setToken(token: string): void {
+    this.accessToken = token;
+  }
+}
+
+export const api = new ApiClient();

package/src/services/auth.ts

@@ -0,0 +1,46 @@
+import fs from 'fs/promises';
+import { getSecretsPath } from '../config';
+
+const SECRETS_FILE = 'secrets.json';
+
+export interface Secrets {
+  access_token: string;
+  refresh_token: string;
+  created_at: string;
+}
+
+export async function saveSecrets(secrets: Secrets): Promise<void> {
+  const filePath = getSecretsPath();
+
+  await fs.writeFile(
+    filePath,
+    JSON.stringify(secrets, null, 2),
+    { mode: 0o600 }  // Only current user can read/write
+  );
+}
+
+export async function loadSecrets(): Promise<Secrets | null> {
+  const filePath = getSecretsPath();
+
+  try {
+    const content = await fs.readFile(filePath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+export async function clearSecrets(): Promise<void> {
+  const filePath = getSecretsPath();
+
+  try {
+    await fs.rm(filePath);
+  } catch {
+    // File doesn't exist, ignore
+  }
+}
+
+export async function getAccessToken(): Promise<string | null> {
+  const secrets = await loadSecrets();
+  return secrets?.access_token || null;
+}

package/src/services/cache.ts

@@ -0,0 +1,101 @@
+import fs from 'fs/promises';
+import { nanoid } from 'nanoid';
+import { getDb } from '../db/client';
+import type { CacheEntry } from '../types/db';
+
+export async function getCachedPlugin(fullName: string, version: string): Promise<CacheEntry | null> {
+  const db = getDb();
+  const result = await db.execute({
+    sql: 'SELECT * FROM plugin_cache WHERE full_name = ? AND version = ?',
+    args: [fullName, version],
+  });
+
+  if (result.rows.length === 0) return null;
+  return result.rows[0] as unknown as CacheEntry;
+}
+
+export async function cachePlugin(entry: {
+  full_name: string;
+  type: string;
+  version: string;
+  cache_path: string;
+  checksum: string;
+}): Promise<void> {
+  const db = getDb();
+  const id = nanoid();
+  const now = new Date().toISOString();
+
+  // Calculate directory size
+  let sizeBytes: number | null = null;
+  try {
+    sizeBytes = await getDirSize(entry.cache_path);
+  } catch {
+    // Ignore
+  }
+
+  await db.execute({
+    sql: `INSERT INTO plugin_cache
+          (id, full_name, type, version, cache_path, checksum, size_bytes, downloaded_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(full_name, version) DO UPDATE SET
+            id = excluded.id,
+            type = excluded.type,
+            cache_path = excluded.cache_path,
+            checksum = excluded.checksum,
+            size_bytes = excluded.size_bytes,
+            downloaded_at = excluded.downloaded_at`,
+    args: [
+      id,
+      entry.full_name,
+      entry.type,
+      entry.version,
+      entry.cache_path,
+      entry.checksum,
+      sizeBytes,
+      now,
+    ],
+  });
+}
+
+export async function removeFromCache(fullName: string, version: string): Promise<void> {
+  const entry = await getCachedPlugin(fullName, version);
+
+  if (entry) {
+    // Delete files
+    try {
+      await fs.rm(entry.cache_path, { recursive: true, force: true });
+    } catch {
+      // Ignore
+    }
+
+    // Delete record
+    const db = getDb();
+    await db.execute({
+      sql: 'DELETE FROM plugin_cache WHERE id = ?',
+      args: [entry.id],
+    });
+  }
+}
+
+export async function getAllCachedPlugins(): Promise<CacheEntry[]> {
+  const db = getDb();
+  const result = await db.execute('SELECT * FROM plugin_cache ORDER BY downloaded_at DESC');
+  return result.rows as unknown as CacheEntry[];
+}
+
+async function getDirSize(dirPath: string): Promise<number> {
+  let size = 0;
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = `${dirPath}/${entry.name}`;
+    if (entry.isDirectory()) {
+      size += await getDirSize(fullPath);
+    } else {
+      const stats = await fs.stat(fullPath);
+      size += stats.size;
+    }
+  }
+
+  return size;
+}