@42ailab/42plugin 0.1.0-beta.1 → 0.1.5

package/src/db/client.ts

@@ -1,180 +0,0 @@
-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/services/api.ts

@@ -1,128 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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;
-}

package/src/services/download.ts

@@ -1,148 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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;
-  }
-}