@42ailab/42plugin 0.1.0-beta.0

package/src/services/download.ts

@@ -0,0 +1,148 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { createWriteStream } from 'fs';
+import { pipeline } from 'stream/promises';
+import * as tar from 'tar';
+import { createHash } from 'crypto';
+import { getCacheDir } from '../config';
+
+export async function downloadAndExtract(
+  url: string,
+  expectedChecksum: string,
+  fullName: string,
+  version: string
+): Promise<string> {
+  // Build cache path
+  const cachePath = buildCachePath(fullName, version);
+  await fs.mkdir(cachePath, { recursive: true });
+
+  // Download file
+  const tempPath = path.join(cachePath, '_download.tar.gz');
+  await downloadFile(url, tempPath);
+
+  // Verify checksum
+  const actualChecksum = await computeFileChecksum(tempPath);
+  const expectedHash = expectedChecksum.replace('sha256:', '');
+  if (actualChecksum !== expectedHash) {
+    await fs.rm(tempPath);
+    throw new Error('Checksum verification failed');
+  }
+
+  // Extract
+  await tar.extract({
+    file: tempPath,
+    cwd: cachePath,
+  });
+
+  // Delete temp file
+  await fs.rm(tempPath);
+
+  // Check if tarball extracted to a single subdirectory (common pattern)
+  // If so, return that subdirectory as the content path
+  const entries = await fs.readdir(cachePath);
+  if (entries.length === 1) {
+    const subPath = path.join(cachePath, entries[0]);
+    const stat = await fs.stat(subPath);
+    if (stat.isDirectory()) {
+      return subPath;
+    }
+  }
+
+  return cachePath;
+}
+
+export function buildCachePath(fullName: string, version: string): string {
+  // fullName formats:
+  // - owner/repo:plugin:type:name (capability from GitHub)
+  // - owner:custom:type:name (custom/curated capability)
+  // - owner/repo:plugin (plugin)
+  // - owner/plugin (simple)
+
+  const parts = fullName.split(':');
+  const [ownerRepo] = parts;
+  const [owner, repo] = ownerRepo.split('/');
+
+  if (parts.length === 4) {
+    const [, pluginName, capType, capName] = parts;
+
+    // Check if this is a custom capability (no slash in first part)
+    if (!repo) {
+      // owner:custom:type:name format (custom capability)
+      return path.join(
+        getCacheDir(),
+        owner,
+        pluginName, // 'custom'
+        capType,
+        capName,
+        version
+      );
+    }
+
+    // owner/repo:plugin:type:name format (GitHub capability)
+    return path.join(
+      getCacheDir(),
+      owner,
+      repo,
+      pluginName,
+      capType,
+      capName,
+      version
+    );
+  } else if (parts.length === 2) {
+    // owner/repo:plugin
+    const [, pluginName] = parts;
+    return path.join(
+      getCacheDir(),
+      owner,
+      repo || 'default',
+      pluginName,
+      version
+    );
+  } else {
+    // owner/plugin (simple format)
+    return path.join(
+      getCacheDir(),
+      owner,
+      repo || 'default',
+      version
+    );
+  }
+}
+
+async function downloadFile(url: string, destPath: string): Promise<void> {
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status}`);
+  }
+
+  if (!response.body) {
+    throw new Error('No response body');
+  }
+
+  const fileStream = createWriteStream(destPath);
+  // Convert Web ReadableStream to Node stream
+  const reader = response.body.getReader();
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      fileStream.write(value);
+    }
+  } finally {
+    reader.releaseLock();
+    fileStream.end();
+  }
+
+  // Wait for file to be fully written
+  await new Promise<void>((resolve, reject) => {
+    fileStream.on('finish', resolve);
+    fileStream.on('error', reject);
+  });
+}
+
+async function computeFileChecksum(filePath: string): Promise<string> {
+  const content = await fs.readFile(filePath);
+  return createHash('sha256').update(content).digest('hex');
+}

package/src/services/link.ts

@@ -0,0 +1,86 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { platform } from '../utils/platform';
+
+const execAsync = promisify(exec);
+
+export async function createLink(source: string, target: string): Promise<void> {
+  // Normalize paths and remove trailing slashes (important for symlink to work correctly)
+  const normalizedSource = source.replace(/\/+$/, '');
+  const normalizedTarget = target.replace(/\/+$/, '');
+
+  // Ensure target directory exists
+  await fs.mkdir(path.dirname(normalizedTarget), { recursive: true });
+
+  // If target already exists, remove it first
+  try {
+    await fs.rm(normalizedTarget, { recursive: true, force: true });
+  } catch {
+    // Ignore
+  }
+
+  // Choose link strategy based on platform
+  if (platform.isWindows) {
+    await createWindowsLink(normalizedSource, normalizedTarget);
+  } else {
+    await createPosixLink(normalizedSource, normalizedTarget);
+  }
+}
+
+async function createPosixLink(source: string, target: string): Promise<void> {
+  try {
+    await fs.symlink(source, target, 'dir');
+  } catch (error) {
+    // symlink failed, fall back to copy
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.warn(`Symlink failed (${errorMsg}), falling back to copy`);
+    await copyDir(source, target);
+  }
+}
+
+async function createWindowsLink(source: string, target: string): Promise<void> {
+  try {
+    // Try to create junction
+    await execAsync(`mklink /J "${target}" "${source}"`);
+  } catch {
+    // junction failed, fall back to copy
+    console.warn('Junction failed, falling back to copy');
+    await copyDir(source, target);
+  }
+}
+
+async function copyDir(source: string, target: string): Promise<void> {
+  await fs.mkdir(target, { recursive: true });
+
+  const entries = await fs.readdir(source, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(source, entry.name);
+    const destPath = path.join(target, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+export async function removeLink(linkPath: string): Promise<void> {
+  try {
+    await fs.rm(linkPath, { recursive: true, force: true });
+  } catch {
+    // Ignore errors
+  }
+}
+
+export async function isSymlink(linkPath: string): Promise<boolean> {
+  try {
+    const stats = await fs.lstat(linkPath);
+    return stats.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}

package/src/services/project.ts

@@ -0,0 +1,179 @@
+import path from 'path';
+import { nanoid } from 'nanoid';
+import { getDb } from '../db/client';
+import type { Project, ProjectPlugin } from '../types/db';
+
+export async function getProject(projectPath: string): Promise<Project | null> {
+  const db = getDb();
+  const result = await db.execute({
+    sql: 'SELECT * FROM projects WHERE path = ?',
+    args: [projectPath],
+  });
+
+  if (result.rows.length === 0) return null;
+  return result.rows[0] as unknown as Project;
+}
+
+export async function getOrCreateProject(projectPath: string): Promise<Project> {
+  let project = await getProject(projectPath);
+
+  if (!project) {
+    const db = getDb();
+    const id = nanoid();
+    const name = path.basename(projectPath);
+    const now = new Date().toISOString();
+
+    await db.execute({
+      sql: `INSERT INTO projects (id, path, name, registered_at, last_used_at)
+            VALUES (?, ?, ?, ?, ?)`,
+      args: [id, projectPath, name, now, now],
+    });
+
+    project = { id, path: projectPath, name, registered_at: now, last_used_at: now };
+  } else {
+    // Update last used time
+    const db = getDb();
+    await db.execute({
+      sql: 'UPDATE projects SET last_used_at = ? WHERE id = ?',
+      args: [new Date().toISOString(), project.id],
+    });
+  }
+
+  return project;
+}
+
+export async function getProjectPlugins(projectId: string): Promise<ProjectPlugin[]> {
+  const db = getDb();
+  const result = await db.execute({
+    sql: 'SELECT * FROM project_plugins WHERE project_id = ?',
+    args: [projectId],
+  });
+
+  return result.rows as unknown as ProjectPlugin[];
+}
+
+export async function getProjectPlugin(projectId: string, fullName: string): Promise<ProjectPlugin | null> {
+  const db = getDb();
+  const result = await db.execute({
+    sql: 'SELECT * FROM project_plugins WHERE project_id = ? AND full_name = ?',
+    args: [projectId, fullName],
+  });
+
+  if (result.rows.length === 0) return null;
+  return result.rows[0] as unknown as ProjectPlugin;
+}
+
+export async function addProjectPlugin(plugin: {
+  project_id: string;
+  full_name: string;
+  type: string;
+  version: string;
+  cache_path: string;
+  link_path: string;
+  source?: string;
+  source_list?: string;
+}): Promise<void> {
+  const db = getDb();
+  const id = nanoid();
+  const now = new Date().toISOString();
+
+  await db.execute({
+    sql: `INSERT INTO project_plugins
+          (id, project_id, full_name, type, version, cache_path, link_path, installed_at, source, source_list)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(project_id, full_name) DO UPDATE SET
+            id = excluded.id,
+            type = excluded.type,
+            version = excluded.version,
+            cache_path = excluded.cache_path,
+            link_path = excluded.link_path,
+            installed_at = excluded.installed_at,
+            source = excluded.source,
+            source_list = excluded.source_list`,
+    args: [
+      id,
+      plugin.project_id,
+      plugin.full_name,
+      plugin.type,
+      plugin.version,
+      plugin.cache_path,
+      plugin.link_path,
+      now,
+      plugin.source || 'direct',
+      plugin.source_list || null,
+    ],
+  });
+}
+
+export async function removeProjectPlugin(
+  projectId: string,
+  fullName: string
+): Promise<ProjectPlugin | null> {
+  const plugin = await findProjectPlugin(projectId, fullName);
+
+  if (!plugin) return null;
+
+  const db = getDb();
+  await db.execute({
+    sql: 'DELETE FROM project_plugins WHERE id = ?',
+    args: [plugin.id],
+  });
+
+  return plugin;
+}
+
+/**
+ * Find a project plugin by various identifier formats:
+ * - Full name: owner:custom:type:name or owner/repo:plugin:type:name
+ * - Slug format: author/slug (e.g., 42plugin/wechat-downloader)
+ * - Simple name: wechat-downloader
+ */
+export async function findProjectPlugin(
+  projectId: string,
+  identifier: string
+): Promise<ProjectPlugin | null> {
+  const db = getDb();
+
+  // 1. Try exact full_name match first
+  let result = await db.execute({
+    sql: 'SELECT * FROM project_plugins WHERE project_id = ? AND full_name = ?',
+    args: [projectId, identifier],
+  });
+  if (result.rows.length > 0) {
+    return result.rows[0] as unknown as ProjectPlugin;
+  }
+
+  // 2. Try matching by slug format (author/name -> find where full_name ends with :type:name)
+  if (identifier.includes('/') && !identifier.includes(':')) {
+    const [author, name] = identifier.split('/');
+    // Match pattern: {author}:custom:{type}:{name} or similar
+    result = await db.execute({
+      sql: `SELECT * FROM project_plugins
+            WHERE project_id = ?
+            AND (full_name LIKE ? OR full_name LIKE ?)`,
+      args: [projectId, `${author}:%:${name}`, `${author}/%:%:${name}`],
+    });
+    if (result.rows.length > 0) {
+      return result.rows[0] as unknown as ProjectPlugin;
+    }
+  }
+
+  // 3. Try matching by simple name (last part of full_name)
+  result = await db.execute({
+    sql: `SELECT * FROM project_plugins
+          WHERE project_id = ?
+          AND full_name LIKE ?`,
+    args: [projectId, `%:${identifier}`],
+  });
+  if (result.rows.length > 0) {
+    return result.rows[0] as unknown as ProjectPlugin;
+  }
+
+  return null;
+}
+
+export async function getAllProjects(): Promise<Project[]> {
+  const db = getDb();
+  const result = await db.execute('SELECT * FROM projects ORDER BY last_used_at DESC');
+  return result.rows as unknown as Project[];
+}

package/src/types/api.ts

@@ -0,0 +1,115 @@
+export interface AuthStartResponse {
+  code: string;
+  auth_url: string;
+  expires_at: string;
+  poll_interval: number;
+}
+
+export interface AuthPollResponse {
+  status: 'pending' | 'completed';
+  access_token?: string;
+  refresh_token?: string;
+  expires_in?: number;
+  user?: {
+    username: string;
+    display_name: string | null;
+    role: string;
+  };
+}
+
+export interface UserProfile {
+  id: string;
+  username: string;
+  display_name: string | null;
+  email: string | null;
+  avatar_url: string | null;
+  role: string;
+  vip_expires_at: string | null;
+  verified: boolean;
+  created_at: string;
+}
+
+export interface CapabilityDownload {
+  full_name: string;
+  version: string;
+  type: string;
+  download_url: string;
+  checksum: string;
+  size_bytes: number;
+  is_paid: boolean;
+  requires_auth: boolean;
+  expires_at?: string;
+  install_path: string;
+}
+
+export interface PluginDetail {
+  full_name: string;
+  name: string;
+  description: string | null;
+  version: string;
+  capabilities: Array<{
+    full_name: string;
+    name: string;
+    type: string;
+    description: string | null;
+  }>;
+}
+
+export interface ListDownload {
+  list: {
+    full_name: string;
+    name: string;
+    description: string | null;
+    price_tier: string | null;
+    effective_price_tier: string;
+  };
+  capabilities: Array<{
+    full_name: string;
+    name: string;
+    type: string;
+    version: string;
+    required: boolean;
+    reason: string | null;
+    download_url: string;
+    checksum: string;
+    size_bytes: number;
+    install_path: string;
+  }>;
+  summary: {
+    total_capabilities: number;
+    required_count: number;
+    optional_count: number;
+    total_size_bytes: number;
+    expires_at: string;
+  };
+}
+
+export interface SearchCapability {
+  full_name: string;
+  slug: string | null;
+  author_username: string | null;
+  short_name: string; // author/slug if available, otherwise full_name
+  name: string;
+  type: string;
+  description: string | null;
+  downloads: number;
+  relevance: number;
+}
+
+export interface SearchList {
+  full_name: string;
+  name: string;
+  capability_count: number;
+  downloads: number;
+  relevance: number;
+}
+
+export interface SearchResult {
+  capabilities: SearchCapability[];
+  lists: SearchList[];
+}
+
+export interface SearchOptions {
+  type?: string;
+  per_page?: number;
+}

package/src/types/db.ts

@@ -0,0 +1,31 @@
+export interface Project {
+  id: string;
+  path: string;
+  name: string;
+  registered_at: string;
+  last_used_at: string;
+}
+
+export interface CacheEntry {
+  id: string;
+  full_name: string;
+  type: string;
+  version: string;
+  cache_path: string;
+  checksum: string;
+  size_bytes: number | null;
+  downloaded_at: string;
+}
+
+export interface ProjectPlugin {
+  id: string;
+  project_id: string;
+  full_name: string;
+  type: string;
+  version: string;
+  cache_path: string;
+  link_path: string;
+  installed_at: string;
+  source: string;
+  source_list: string | null;
+}

package/src/utils/errors.ts

@@ -0,0 +1,40 @@
+export class CliError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public exitCode: number = 1
+  ) {
+    super(message);
+    this.name = 'CliError';
+  }
+}
+
+export class AuthError extends CliError {
+  constructor(message: string) {
+    super(message, 'AUTH_ERROR', 1);
+  }
+}
+
+export class NetworkError extends CliError {
+  constructor(message: string) {
+    super(message, 'NETWORK_ERROR', 1);
+  }
+}
+
+export class NotFoundError extends CliError {
+  constructor(resource: string) {
+    super(`Not found: ${resource}`, 'NOT_FOUND', 1);
+  }
+}
+
+export class PermissionError extends CliError {
+  constructor(message: string) {
+    super(message, 'PERMISSION_ERROR', 1);
+  }
+}
+
+export class ValidationError extends CliError {
+  constructor(message: string) {
+    super(message, 'VALIDATION_ERROR', 1);
+  }
+}

package/src/utils/platform.ts

@@ -0,0 +1,6 @@
+export const platform = {
+  isWindows: process.platform === 'win32',
+  isMac: process.platform === 'darwin',
+  isLinux: process.platform === 'linux',
+  isPosix: process.platform !== 'win32',
+};