profclaw 2.0.0 → 2.3.0

package/dist/skills/marketplace.js

@@ -0,0 +1,268 @@
+/**
+ * Skill Marketplace Client
+ *
+ * Enables discovering, installing, and updating skills from remote registries.
+ * Supports the profClaw skill registry (future) and GitHub-hosted skills.
+ *
+ * Skills are installed to ~/.profclaw/skills/<name>/SKILL.md
+ */
+import { join } from 'node:path';
+import { mkdir, writeFile, readFile, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { logger } from '../utils/logger.js';
+// Default registries
+const DEFAULT_REGISTRIES = [
+    {
+        name: 'profclaw-community',
+        url: 'https://registry.profclaw.ai/api/v1',
+        enabled: true,
+    },
+    {
+        name: 'clawhub',
+        url: 'https://clawhub.dev/api/v1',
+        enabled: true,
+    },
+];
+// Marketplace Client
+const MANAGED_SKILLS_DIR = join(homedir(), '.profclaw', 'skills');
+export class MarketplaceClient {
+    registries;
+    constructor(registries) {
+        this.registries = registries || [...DEFAULT_REGISTRIES];
+    }
+    /**
+     * Search for skills across all enabled registries.
+     */
+    async search(params = {}) {
+        const results = [];
+        for (const registry of this.registries.filter((r) => r.enabled)) {
+            try {
+                const skills = await this.searchRegistry(registry, params);
+                results.push(...skills);
+            }
+            catch (error) {
+                logger.warn(`[Marketplace] Failed to search ${registry.name}: ${error instanceof Error ? error.message : 'Unknown'}`);
+            }
+        }
+        // Sort results
+        const sortBy = params.sortBy || 'installs';
+        results.sort((a, b) => {
+            switch (sortBy) {
+                case 'installs': return b.installs - a.installs;
+                case 'rating': return b.rating - a.rating;
+                case 'updated': return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+                case 'name': return a.name.localeCompare(b.name);
+                default: return 0;
+            }
+        });
+        return results.slice(0, params.limit || 50);
+    }
+    /**
+     * Install a skill from a registry or direct URL.
+     */
+    async install(source) {
+        try {
+            let skillContent;
+            let skillName;
+            if (source.startsWith('http://') || source.startsWith('https://')) {
+                // Direct URL install
+                const result = await this.fetchSkillFromUrl(source);
+                skillContent = result.content;
+                skillName = result.name;
+            }
+            else if (source.includes('/')) {
+                // GitHub shorthand: owner/repo or owner/repo/path
+                const result = await this.fetchSkillFromGitHub(source);
+                skillContent = result.content;
+                skillName = result.name;
+            }
+            else {
+                // Registry skill name
+                const result = await this.fetchSkillFromRegistry(source);
+                skillContent = result.content;
+                skillName = result.name;
+            }
+            // Install to managed skills directory
+            const installDir = join(MANAGED_SKILLS_DIR, skillName);
+            await mkdir(installDir, { recursive: true });
+            const installPath = join(installDir, 'SKILL.md');
+            await writeFile(installPath, skillContent, 'utf-8');
+            // Parse version from frontmatter
+            const versionMatch = skillContent.match(/version:\s*(.+)/);
+            const version = versionMatch ? versionMatch[1].trim() : 'unknown';
+            logger.info(`[Marketplace] Installed skill: ${skillName} v${version} to ${installPath}`);
+            return {
+                success: true,
+                skillName,
+                version,
+                installPath,
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Install failed';
+            logger.error(`[Marketplace] Install failed for ${source}: ${msg}`);
+            return {
+                success: false,
+                skillName: source,
+                error: msg,
+            };
+        }
+    }
+    /**
+     * Uninstall a managed skill.
+     */
+    async uninstall(skillName) {
+        const skillDir = join(MANAGED_SKILLS_DIR, skillName);
+        try {
+            await rm(skillDir, { recursive: true });
+            logger.info(`[Marketplace] Uninstalled skill: ${skillName}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check for updates to installed managed skills.
+     */
+    async checkUpdates() {
+        const updates = [];
+        try {
+            const { readdir } = await import('node:fs/promises');
+            const dirs = await readdir(MANAGED_SKILLS_DIR).catch(() => []);
+            for (const dir of dirs) {
+                const skillPath = join(MANAGED_SKILLS_DIR, dir, 'SKILL.md');
+                try {
+                    const content = await readFile(skillPath, 'utf-8');
+                    const versionMatch = content.match(/version:\s*(.+)/);
+                    const currentVersion = versionMatch ? versionMatch[1].trim() : 'unknown';
+                    // Check registry for latest version
+                    const latest = await this.getLatestVersion(dir);
+                    if (latest && latest !== currentVersion) {
+                        updates.push({ name: dir, currentVersion, latestVersion: latest });
+                    }
+                }
+                catch {
+                    // Skip skills we can't read
+                }
+            }
+        }
+        catch {
+            // No managed skills directory
+        }
+        return updates;
+    }
+    /**
+     * Add a custom registry.
+     */
+    addRegistry(registry) {
+        const existing = this.registries.findIndex((r) => r.name === registry.name);
+        if (existing >= 0) {
+            this.registries[existing] = registry;
+        }
+        else {
+            this.registries.push(registry);
+        }
+    }
+    /**
+     * List configured registries.
+     */
+    listRegistries() {
+        return [...this.registries];
+    }
+    // Private methods
+    async searchRegistry(registry, params) {
+        const url = new URL(`${registry.url}/skills`);
+        if (params.query)
+            url.searchParams.set('q', params.query);
+        if (params.category)
+            url.searchParams.set('category', params.category);
+        if (params.tag)
+            url.searchParams.set('tag', params.tag);
+        if (params.limit)
+            url.searchParams.set('limit', String(params.limit));
+        if (params.offset)
+            url.searchParams.set('offset', String(params.offset));
+        const response = await fetch(url.toString(), {
+            headers: { 'User-Agent': 'profClaw/2.0 Marketplace' },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!response.ok) {
+            throw new Error(`Registry ${registry.name} returned ${response.status}`);
+        }
+        const data = await response.json();
+        return data.skills || [];
+    }
+    async fetchSkillFromUrl(url) {
+        const response = await fetch(url, {
+            headers: { 'User-Agent': 'profClaw/2.0 Marketplace' },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch skill: HTTP ${response.status}`);
+        }
+        const content = await response.text();
+        const nameMatch = content.match(/name:\s*(.+)/);
+        const name = nameMatch ? nameMatch[1].trim() : `skill-${Date.now()}`;
+        return { content, name };
+    }
+    async fetchSkillFromGitHub(shorthand) {
+        // Parse: owner/repo or owner/repo/path/to/SKILL.md
+        const parts = shorthand.split('/');
+        if (parts.length < 2) {
+            throw new Error(`Invalid GitHub shorthand: ${shorthand}. Use owner/repo or owner/repo/path`);
+        }
+        const owner = parts[0];
+        const repo = parts[1];
+        const path = parts.length > 2 ? parts.slice(2).join('/') : 'SKILL.md';
+        const url = `https://raw.githubusercontent.com/${owner}/${repo}/main/${path}`;
+        return this.fetchSkillFromUrl(url);
+    }
+    async fetchSkillFromRegistry(name) {
+        for (const registry of this.registries.filter((r) => r.enabled)) {
+            try {
+                const url = `${registry.url}/skills/${encodeURIComponent(name)}/content`;
+                const response = await fetch(url, {
+                    headers: { 'User-Agent': 'profClaw/2.0 Marketplace' },
+                    signal: AbortSignal.timeout(10000),
+                });
+                if (response.ok) {
+                    const content = await response.text();
+                    return { content, name };
+                }
+            }
+            catch {
+                // Try next registry
+            }
+        }
+        throw new Error(`Skill "${name}" not found in any registry`);
+    }
+    async getLatestVersion(skillName) {
+        for (const registry of this.registries.filter((r) => r.enabled)) {
+            try {
+                const url = `${registry.url}/skills/${encodeURIComponent(skillName)}`;
+                const response = await fetch(url, {
+                    headers: { 'User-Agent': 'profClaw/2.0 Marketplace' },
+                    signal: AbortSignal.timeout(5000),
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    return data.version || null;
+                }
+            }
+            catch {
+                // Try next registry
+            }
+        }
+        return null;
+    }
+}
+// Singleton
+let marketplaceInstance = null;
+export function getMarketplace() {
+    if (!marketplaceInstance) {
+        marketplaceInstance = new MarketplaceClient();
+    }
+    return marketplaceInstance;
+}
+//# sourceMappingURL=marketplace.js.map

package/dist/storage/index.d.ts

@@ -2,6 +2,16 @@ import type { StorageAdapter } from "./adapter.js";
 import type { LibSQLDatabase } from "drizzle-orm/libsql";
 import type { Client } from "@libsql/client";
 import * as schema from "./schema.js";
+import { type MigrationDb } from "./migrations.js";
+/**
+ * Wraps a libsql Client into the MigrationDb interface expected by runMigrations.
+ */
+export declare function buildMigrationDb(client: Client): MigrationDb;
+/**
+ * Returns true if the active storage backend is ephemeral (in-memory).
+ * Always returns false before initStorage() has been called.
+ */
+export declare function isStorageInMemory(): boolean;
 /**
  * Initialize storage based on configuration
  */
@@ -18,6 +28,10 @@ export declare function getDb(): LibSQLDatabase<typeof schema>;
  * Get the raw libsql client for executing raw SQL
  */
 export declare function getClient(): Client;
+/**
+ * Close the global storage connection. Call before process exit in CLI commands.
+ */
+export declare function closeStorage(): Promise<void>;
 export * from "./adapter.js";
 export * from "./schema.js";
 export interface SavedProviderConfig {

package/dist/storage/index.js

@@ -1,8 +1,34 @@
 import { LibSQLAdapter } from "./libsql.js";
 import { loadConfig } from "../utils/config-loader.js";
 import { createContextualLogger } from "../utils/logger.js";
+import { runMigrations } from "./migrations.js";
 const log = createContextualLogger('Storage');
+/**
+ * Wraps a libsql Client into the MigrationDb interface expected by runMigrations.
+ */
+export function buildMigrationDb(client) {
+    return {
+        execute: async (sql, params) => {
+            const result = await client.execute({
+                sql,
+                args: (params ?? []),
+            });
+            return {
+                rows: result.rows,
+                rowsAffected: result.rowsAffected,
+            };
+        },
+    };
+}
 let storage = null;
+let storageIsInMemory = false;
+/**
+ * Returns true if the active storage backend is ephemeral (in-memory).
+ * Always returns false before initStorage() has been called.
+ */
+export function isStorageInMemory() {
+    return storageIsInMemory;
+}
 /**
  * Initialize storage based on configuration
  */
@@ -19,23 +45,49 @@ export async function initStorage() {
     if (tier === "file") {
         tier = "local";
     }
-    if (databaseUrl && tier === "memory") {
-        // DATABASE_URL implies persistent storage
-        tier = "local";
+    // Extract path from DATABASE_URL when present (works for any tier)
+    if (databaseUrl) {
         dbPathOverride = databaseUrl.startsWith("file:")
             ? databaseUrl.slice(5)
             : databaseUrl;
+        // DATABASE_URL implies persistent storage even if tier was "memory"
+        if (tier === "memory") {
+            tier = "local";
+        }
     }
     if (tier === "local") {
         const dbPath = dbPathOverride || process.env.DB_PATH || settings.storage?.dbPath;
         storage = new LibSQLAdapter({ dbPath });
+        storageIsInMemory = false;
         log.info('Initializing LibSQL storage', { dbPath: dbPath || 'default path' });
     }
     else {
+        storageIsInMemory = true;
         log.info('Initializing in-memory storage (LibSQL in-memory)');
         storage = new LibSQLAdapter({ dbPath: ":memory:" });
     }
     await storage.connect();
+    // Auto-run migrations on startup so first-time users don't hit schema errors
+    try {
+        const migrationDb = buildMigrationDb(storage.getClient());
+        const result = await runMigrations(migrationDb);
+        if (result.applied > 0) {
+            log.info('Auto-migration complete', {
+                applied: result.applied,
+                currentVersion: result.currentVersion,
+                migrations: result.migrations,
+            });
+        }
+        else {
+            log.debug('Schema is up to date', { currentVersion: result.currentVersion });
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log.error('Auto-migration failed', { error: message });
+        throw new Error(`Database migration failed during startup: ${message}\n` +
+            `To diagnose, run: profclaw db:migrate --verbose`);
+    }
     return storage;
 }
 /**
@@ -65,6 +117,15 @@ export function getClient() {
     }
     return storage.getClient();
 }
+/**
+ * Close the global storage connection. Call before process exit in CLI commands.
+ */
+export async function closeStorage() {
+    if (storage) {
+        await storage.disconnect();
+        storage = null;
+    }
+}
 export * from "./adapter.js";
 export * from "./schema.js";
 /**

package/dist/storage/schema.d.ts

@@ -7488,7 +7488,7 @@ export declare const scheduledJobs: import("drizzle-orm/sqlite-core").SQLiteTabl
             columnType: "SQLiteTextJson";
             data: {
                 channels: Array<{
-                    type: "slack" | "webhook" | "email";
+                    type: "slack" | "webhook" | "email" | "telegram" | "discord";
                     target: string;
                     onSuccess?: boolean;
                     onFailure?: boolean;
@@ -7507,7 +7507,7 @@ export declare const scheduledJobs: import("drizzle-orm/sqlite-core").SQLiteTabl
         }, {}, {
             $type: {
                 channels: Array<{
-                    type: "slack" | "webhook" | "email";
+                    type: "slack" | "webhook" | "email" | "telegram" | "discord";
                     target: string;
                     onSuccess?: boolean;
                     onFailure?: boolean;
@@ -8908,7 +8908,7 @@ export declare const jobTemplates: import("drizzle-orm/sqlite-core").SQLiteTable
             columnType: "SQLiteTextJson";
             data: {
                 channels: Array<{
-                    type: "slack" | "webhook" | "email";
+                    type: "slack" | "webhook" | "email" | "telegram" | "discord";
                     target: string;
                     onSuccess?: boolean;
                     onFailure?: boolean;
@@ -8927,7 +8927,7 @@ export declare const jobTemplates: import("drizzle-orm/sqlite-core").SQLiteTable
         }, {}, {
             $type: {
                 channels: Array<{
-                    type: "slack" | "webhook" | "email";
+                    type: "slack" | "webhook" | "email" | "telegram" | "discord";
                     target: string;
                     onSuccess?: boolean;
                     onFailure?: boolean;

package/dist/storage/schema.js

@@ -825,7 +825,7 @@ export const scheduledJobs = sqliteTable("scheduled_jobs", {
     // Event triggers (for event-driven jobs)
     eventTrigger: text("event_trigger", { mode: "json" }).$type(),
     // Job type and payload
-    jobType: text("job_type").notNull(), // 'http' | 'tool' | 'script' | 'message'
+    jobType: text("job_type").notNull(), // 'http' | 'tool' | 'script' | 'message' | 'agent_session'
     payload: text("payload", { mode: "json" })
         .$type()
         .notNull(),

package/dist/teams/index.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Team Management System
+ *
+ * Multi-user teams with shared cost budgets, role-based access,
+ * and per-member usage tracking.
+ *
+ * No other OSS AI tool has this - enterprise unlock for profClaw.
+ *
+ * Roles:
+ *   owner  - full control, billing, can delete team
+ *   admin  - manage members, budgets, settings
+ *   member - use AI, view costs, manage own preferences
+ *   viewer - read-only access to dashboards and history
+ */
+export type TeamRole = 'owner' | 'admin' | 'member' | 'viewer';
+export interface Team {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    avatarUrl?: string;
+    ownerId: string;
+    monthlyBudgetUsd: number;
+    dailyBudgetUsd: number;
+    budgetAlertThresholds: number[];
+    defaultModel?: string;
+    preferredProviders: string[];
+    smartRoutingEnabled: boolean;
+    memberCount: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface TeamMember {
+    id: string;
+    teamId: string;
+    userId: string;
+    role: TeamRole;
+    personalBudgetUsd?: number;
+    preferredModel?: string;
+    totalSpentUsd: number;
+    requestCount: number;
+    lastActiveAt?: number;
+    joinedAt: number;
+    invitedBy?: string;
+}
+export interface TeamInvite {
+    id: string;
+    teamId: string;
+    email: string;
+    role: TeamRole;
+    invitedBy: string;
+    expiresAt: number;
+    acceptedAt?: number;
+}
+export interface TeamUsageSummary {
+    teamId: string;
+    period: 'daily' | 'weekly' | 'monthly';
+    totalSpentUsd: number;
+    budgetUsd: number;
+    budgetUsedPercent: number;
+    memberBreakdown: Array<{
+        userId: string;
+        name?: string;
+        spentUsd: number;
+        requestCount: number;
+        topModel?: string;
+    }>;
+    alertsTriggered: number[];
+}
+export declare function initTeamsTables(): Promise<void>;
+export declare function createTeam(params: {
+    name: string;
+    slug?: string;
+    description?: string;
+    ownerId: string;
+    monthlyBudget?: number;
+    dailyBudget?: number;
+}): Promise<Team>;
+export declare function getTeam(teamId: string): Promise<Team | null>;
+export declare function getTeamBySlug(slug: string): Promise<Team | null>;
+export declare function listUserTeams(userId: string): Promise<Team[]>;
+export declare function updateTeam(teamId: string, updates: Partial<{
+    name: string;
+    description: string;
+    monthlyBudgetUsd: number;
+    dailyBudgetUsd: number;
+    budgetAlertThresholds: number[];
+    defaultModel: string;
+    preferredProviders: string[];
+    smartRoutingEnabled: boolean;
+}>): Promise<Team | null>;
+export declare function deleteTeam(teamId: string): Promise<boolean>;
+export declare function addMember(teamId: string, userId: string, role?: TeamRole, invitedBy?: string): Promise<TeamMember>;
+export declare function removeMember(teamId: string, userId: string): Promise<boolean>;
+export declare function getMember(teamId: string, userId: string): Promise<TeamMember | null>;
+export declare function listMembers(teamId: string): Promise<TeamMember[]>;
+export declare function updateMemberRole(teamId: string, userId: string, newRole: TeamRole): Promise<boolean>;
+export declare function recordMemberUsage(teamId: string, userId: string, costUsd: number): Promise<void>;
+export declare function getTeamUsage(teamId: string): Promise<TeamUsageSummary>;
+/**
+ * Check if a member can make a request (budget check).
+ */
+export declare function canMemberSpend(teamId: string, userId: string, estimatedCostUsd: number): Promise<{
+    allowed: boolean;
+    reason?: string;
+}>;
+export declare function createInvite(teamId: string, email: string, role: TeamRole, invitedBy: string): Promise<TeamInvite>;
+export declare function acceptInvite(inviteId: string, userId: string): Promise<TeamMember | null>;
+export declare function listTeamInvites(teamId: string): Promise<TeamInvite[]>;
+//# sourceMappingURL=index.d.ts.map