@plures/praxis 1.0.3 → 1.1.0

package/dist/node/chunk-DSDC2JWZ.js

@@ -0,0 +1,256 @@
+// src/cloud/billing.ts
+var SubscriptionTier = /* @__PURE__ */ ((SubscriptionTier2) => {
+  SubscriptionTier2["FREE"] = "free";
+  SubscriptionTier2["SOLO"] = "solo";
+  SubscriptionTier2["TEAM"] = "team";
+  SubscriptionTier2["ENTERPRISE"] = "enterprise";
+  return SubscriptionTier2;
+})(SubscriptionTier || {});
+var BillingProvider = /* @__PURE__ */ ((BillingProvider2) => {
+  BillingProvider2["SPONSORS"] = "sponsors";
+  BillingProvider2["MARKETPLACE"] = "marketplace";
+  BillingProvider2["NONE"] = "none";
+  return BillingProvider2;
+})(BillingProvider || {});
+var SubscriptionStatus = /* @__PURE__ */ ((SubscriptionStatus2) => {
+  SubscriptionStatus2["ACTIVE"] = "active";
+  SubscriptionStatus2["CANCELLED"] = "cancelled";
+  SubscriptionStatus2["EXPIRED"] = "expired";
+  SubscriptionStatus2["NONE"] = "none";
+  return SubscriptionStatus2;
+})(SubscriptionStatus || {});
+var TIER_LIMITS = {
+  ["free" /* FREE */]: {
+    maxSyncsPerMonth: 1e3,
+    maxStorageBytes: 10 * 1024 * 1024,
+    // 10 MB
+    maxTeamMembers: 1,
+    maxApps: 1,
+    supportLevel: "community"
+  },
+  ["solo" /* SOLO */]: {
+    maxSyncsPerMonth: 5e4,
+    maxStorageBytes: 1024 * 1024 * 1024,
+    // 1 GB
+    maxTeamMembers: 1,
+    maxApps: 10,
+    supportLevel: "standard"
+  },
+  ["team" /* TEAM */]: {
+    maxSyncsPerMonth: 5e5,
+    maxStorageBytes: 10 * 1024 * 1024 * 1024,
+    // 10 GB
+    maxTeamMembers: 10,
+    maxApps: 50,
+    supportLevel: "standard"
+  },
+  ["enterprise" /* ENTERPRISE */]: {
+    maxSyncsPerMonth: 5e6,
+    maxStorageBytes: 100 * 1024 * 1024 * 1024,
+    // 100 GB
+    maxTeamMembers: null,
+    // unlimited
+    maxApps: 1e3,
+    supportLevel: "priority"
+  }
+};
+function hasAccessToTier(subscription, requiredTier) {
+  if (subscription.status !== "active" /* ACTIVE */) {
+    return false;
+  }
+  const tierOrder = [
+    "free" /* FREE */,
+    "solo" /* SOLO */,
+    "team" /* TEAM */,
+    "enterprise" /* ENTERPRISE */
+  ];
+  const currentTierIndex = tierOrder.indexOf(subscription.tier);
+  const requiredTierIndex = tierOrder.indexOf(requiredTier);
+  return currentTierIndex >= requiredTierIndex;
+}
+function checkUsageLimits(subscription, usage) {
+  const violations = [];
+  if (usage.syncCount > subscription.limits.maxSyncsPerMonth) {
+    violations.push(
+      `Sync limit exceeded: ${usage.syncCount}/${subscription.limits.maxSyncsPerMonth}`
+    );
+  }
+  if (usage.storageBytes > subscription.limits.maxStorageBytes) {
+    violations.push(
+      `Storage limit exceeded: ${(usage.storageBytes / 1024 / 1024).toFixed(2)}MB/${(subscription.limits.maxStorageBytes / 1024 / 1024).toFixed(2)}MB`
+    );
+  }
+  if (subscription.limits.maxTeamMembers !== null && usage.teamMembers > subscription.limits.maxTeamMembers) {
+    violations.push(
+      `Team member limit exceeded: ${usage.teamMembers}/${subscription.limits.maxTeamMembers}`
+    );
+  }
+  if (usage.appCount > subscription.limits.maxApps) {
+    violations.push(`App limit exceeded: ${usage.appCount}/${subscription.limits.maxApps}`);
+  }
+  return {
+    withinLimits: violations.length === 0,
+    violations
+  };
+}
+function createFreeSubscription() {
+  return {
+    tier: "free" /* FREE */,
+    status: "active" /* ACTIVE */,
+    provider: "none" /* NONE */,
+    startDate: Date.now(),
+    autoRenew: true,
+    limits: TIER_LIMITS["free" /* FREE */]
+  };
+}
+function createSponsorSubscription(tierName, monthlyPriceInCents) {
+  let tier = "free" /* FREE */;
+  if (monthlyPriceInCents >= 5e3) {
+    tier = "enterprise" /* ENTERPRISE */;
+  } else if (monthlyPriceInCents >= 2e3) {
+    tier = "team" /* TEAM */;
+  } else if (monthlyPriceInCents >= 500) {
+    tier = "solo" /* SOLO */;
+  }
+  return {
+    tier,
+    status: "active" /* ACTIVE */,
+    provider: "sponsors" /* SPONSORS */,
+    sponsorTierId: tierName,
+    startDate: Date.now(),
+    autoRenew: true,
+    limits: TIER_LIMITS[tier]
+  };
+}
+
+// src/cloud/sponsors.ts
+var GitHubSponsorsClient = class {
+  token;
+  accountLogin;
+  constructor(token, accountLogin) {
+    this.token = token;
+    this.accountLogin = accountLogin;
+  }
+  /**
+   * Get current user's sponsorship of the Praxis account
+   */
+  async getSponsorship(userLogin) {
+    try {
+      const query = `
+        query($accountLogin: String!, $userLogin: String!) {
+          user(login: $userLogin) {
+            sponsorshipForViewerAsSponsor(activeOnly: true) {
+              tier {
+                id
+                name
+                monthlyPriceInCents
+                description
+                isOneTime
+              }
+              createdAt
+              isActive
+            }
+            sponsorshipsAsSponsor(first: 100, activeOnly: true) {
+              nodes {
+                sponsorable {
+                  ... on User {
+                    login
+                  }
+                  ... on Organization {
+                    login
+                  }
+                }
+                tier {
+                  id
+                  name
+                  monthlyPriceInCents
+                  description
+                  isOneTime
+                }
+                createdAt
+                isActive
+              }
+            }
+          }
+        }
+      `;
+      const response = await fetch("https://api.github.com/graphql", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          query,
+          variables: {
+            accountLogin: this.accountLogin,
+            userLogin
+          }
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.errors) {
+        throw new Error(`GraphQL error: ${JSON.stringify(data.errors)}`);
+      }
+      const sponsorships = data.data?.user?.sponsorshipsAsSponsor?.nodes || [];
+      const praxisSponsorship = sponsorships.find(
+        (s) => s.sponsorable?.login === this.accountLogin
+      );
+      if (!praxisSponsorship) {
+        return null;
+      }
+      return {
+        sponsorLogin: userLogin,
+        sponsorId: data.data.user.id,
+        tier: {
+          id: praxisSponsorship.tier.id,
+          name: praxisSponsorship.tier.name,
+          monthlyPriceInCents: praxisSponsorship.tier.monthlyPriceInCents,
+          description: praxisSponsorship.tier.description,
+          isOneTime: praxisSponsorship.tier.isOneTime
+        },
+        createdAt: praxisSponsorship.createdAt,
+        isActive: praxisSponsorship.isActive
+      };
+    } catch (error) {
+      console.error("Failed to get sponsorship:", error);
+      return null;
+    }
+  }
+  /**
+   * Get subscription from sponsorship
+   */
+  async getSubscription(userLogin) {
+    const sponsorship = await this.getSponsorship(userLogin);
+    if (!sponsorship || !sponsorship.isActive) {
+      return createFreeSubscription();
+    }
+    return createSponsorSubscription(sponsorship.tier.name, sponsorship.tier.monthlyPriceInCents);
+  }
+  /**
+   * Check if user is a sponsor
+   */
+  async isSponsor(userLogin) {
+    const sponsorship = await this.getSponsorship(userLogin);
+    return sponsorship !== null && sponsorship.isActive;
+  }
+};
+function createSponsorsClient(token, accountLogin = "plures") {
+  return new GitHubSponsorsClient(token, accountLogin);
+}
+
+export {
+  SubscriptionTier,
+  BillingProvider,
+  SubscriptionStatus,
+  TIER_LIMITS,
+  hasAccessToTier,
+  checkUsageLimits,
+  createFreeSubscription,
+  createSponsorSubscription,
+  GitHubSponsorsClient,
+  createSponsorsClient
+};

package/dist/node/chunk-FXQZXAWF.js

@@ -0,0 +1,175 @@
+// src/cloud/auth.ts
+var GitHubOAuth = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Get the OAuth authorization URL
+   */
+  getAuthorizationUrl(state) {
+    const params = new URLSearchParams({
+      client_id: this.config.clientId,
+      scope: this.config.scope || "read:user user:email",
+      state: state || this.generateState()
+    });
+    if (this.config.redirectUri) {
+      params.set("redirect_uri", this.config.redirectUri);
+    }
+    return `https://github.com/login/oauth/authorize?${params.toString()}`;
+  }
+  /**
+   * Exchange authorization code for access token
+   */
+  async exchangeCode(code) {
+    if (!this.config.clientSecret) {
+      throw new Error("Client secret is required for code exchange");
+    }
+    try {
+      const response = await fetch("https://github.com/login/oauth/access_token", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify({
+          client_id: this.config.clientId,
+          client_secret: this.config.clientSecret,
+          code
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Token exchange failed: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.error) {
+        throw new Error(`GitHub OAuth error: ${data.error_description || data.error}`);
+      }
+      const user = await this.getUserInfo(data.access_token);
+      return {
+        success: true,
+        token: data.access_token,
+        user,
+        expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
+      };
+    } catch (error) {
+      return {
+        success: false
+      };
+    }
+  }
+  /**
+   * Get user information from GitHub
+   */
+  async getUserInfo(token) {
+    const response = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get user info: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      id: data.id,
+      login: data.login,
+      email: data.email,
+      name: data.name,
+      avatarUrl: data.avatar_url
+    };
+  }
+  /**
+   * Verify a token is valid
+   */
+  async verifyToken(token) {
+    try {
+      await this.getUserInfo(token);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Generate a random state parameter for CSRF protection
+   */
+  generateState() {
+    const array = new Uint8Array(16);
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      crypto.getRandomValues(array);
+    } else {
+      for (let i = 0; i < array.length; i++) {
+        array[i] = Math.floor(Math.random() * 256);
+      }
+    }
+    return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+};
+function createGitHubOAuth(config) {
+  return new GitHubOAuth(config);
+}
+async function authenticateWithDeviceFlow(clientId) {
+  try {
+    const deviceResponse = await fetch("https://github.com/login/device/code", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({
+        client_id: clientId,
+        scope: "read:user user:email"
+      })
+    });
+    if (!deviceResponse.ok) {
+      throw new Error(`Device flow initiation failed: ${deviceResponse.statusText}`);
+    }
+    const deviceData = await deviceResponse.json();
+    console.log("\nTo authenticate with GitHub:");
+    console.log(`1. Visit: ${deviceData.verification_uri}`);
+    console.log(`2. Enter code: ${deviceData.user_code}`);
+    console.log("\nWaiting for authentication...\n");
+    const interval = deviceData.interval * 1e3 || 5e3;
+    const expiresAt = Date.now() + deviceData.expires_in * 1e3;
+    while (Date.now() < expiresAt) {
+      await new Promise((resolve) => setTimeout(resolve, interval));
+      const tokenResponse = await fetch("https://github.com/login/oauth/access_token", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify({
+          client_id: clientId,
+          device_code: deviceData.device_code,
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+        })
+      });
+      const tokenData = await tokenResponse.json();
+      if (tokenData.access_token) {
+        const oauth = new GitHubOAuth({ clientId });
+        const user = await oauth.getUserInfo(tokenData.access_token);
+        return {
+          success: true,
+          token: tokenData.access_token,
+          user
+        };
+      }
+      if (tokenData.error && tokenData.error !== "authorization_pending") {
+        throw new Error(`Authentication failed: ${tokenData.error_description || tokenData.error}`);
+      }
+    }
+    throw new Error("Authentication timeout");
+  } catch (error) {
+    return {
+      success: false
+    };
+  }
+}
+
+export {
+  GitHubOAuth,
+  createGitHubOAuth,
+  authenticateWithDeviceFlow
+};

package/dist/node/chunk-N5Y37EUV.js

@@ -0,0 +1,202 @@
+// src/runtime/terminal-adapter.ts
+async function defaultExecutor(command, options) {
+  try {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+    const processEnv = typeof process !== "undefined" ? process.env : {};
+    const result = await execAsync(command, {
+      cwd: options.cwd,
+      env: { ...processEnv, ...options.env },
+      maxBuffer: 10 * 1024 * 1024,
+      // 10MB buffer
+      timeout: 6e4
+      // 60 second timeout
+    });
+    return {
+      output: result.stdout + (result.stderr ? `
+${result.stderr}` : ""),
+      exitCode: 0
+    };
+  } catch (error) {
+    const execError = error;
+    return {
+      output: (execError.stdout || "") + (execError.stderr || ""),
+      exitCode: execError.code || 1,
+      error: execError.message || "Command execution failed"
+    };
+  }
+}
+var TerminalAdapter = class {
+  state;
+  inputPath;
+  outputPath;
+  db;
+  executor;
+  constructor(options) {
+    this.state = {
+      nodeId: options.nodeId,
+      inputMode: options.props?.inputMode || "text",
+      history: options.props?.history || [],
+      lastOutput: options.props?.lastOutput || null,
+      cwd: options.cwd,
+      env: options.env
+    };
+    this.inputPath = options.inputPath;
+    this.outputPath = options.outputPath;
+    this.db = options.db;
+    this.executor = options.executor || defaultExecutor;
+  }
+  /**
+   * Execute a terminal command
+   *
+   * @param command - Command to execute
+   * @returns Execution result
+   */
+  async executeCommand(command) {
+    this.state.history.push(command);
+    const timestamp = Date.now();
+    const { output, exitCode, error } = await this.executor(command, {
+      cwd: this.state.cwd,
+      env: this.state.env
+    });
+    const result = {
+      command,
+      output,
+      exitCode,
+      timestamp,
+      error
+    };
+    this.state.lastOutput = output;
+    if (this.db && this.outputPath) {
+      await this.syncToPluresDB(this.outputPath, result);
+    }
+    return result;
+  }
+  /**
+   * Get current terminal state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Update terminal props
+   */
+  updateProps(props) {
+    this.state = {
+      ...this.state,
+      ...props
+    };
+  }
+  /**
+   * Set working directory
+   */
+  setCwd(cwd) {
+    this.state.cwd = cwd;
+  }
+  /**
+   * Set environment variables
+   */
+  setEnv(env) {
+    this.state.env = { ...this.state.env, ...env };
+  }
+  /**
+   * Clear command history
+   */
+  clearHistory() {
+    this.state.history = [];
+  }
+  /**
+   * Get command history
+   */
+  getHistory() {
+    return [...this.state.history];
+  }
+  /**
+   * Sync state to PluresDB
+   *
+   * @param path - PluresDB path for storing results
+   * @param data - Data to sync
+   */
+  async syncToPluresDB(path, data) {
+    if (!this.db) return;
+    try {
+      await this.db.set(path, {
+        ...data,
+        nodeId: this.state.nodeId,
+        syncedAt: Date.now()
+      });
+      const historyPath = `${path}/history`;
+      const historyKey = `${historyPath}/${data.timestamp}`;
+      await this.db.set(historyKey, data);
+    } catch (error) {
+      console.warn("Failed to sync to PluresDB:", error);
+    }
+  }
+  /**
+   * Load state from PluresDB
+   */
+  async loadFromPluresDB() {
+    if (!this.db || !this.inputPath) return;
+    try {
+      const data = await this.db.get(this.inputPath);
+      if (data && typeof data === "object") {
+        const savedState = data;
+        if (savedState.history) {
+          this.state.history = savedState.history;
+        }
+        if (savedState.lastOutput !== void 0) {
+          this.state.lastOutput = savedState.lastOutput;
+        }
+        if (savedState.cwd) {
+          this.state.cwd = savedState.cwd;
+        }
+        if (savedState.env) {
+          this.state.env = savedState.env;
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to load from PluresDB:", error);
+    }
+  }
+  /**
+   * Subscribe to input changes from PluresDB
+   */
+  watchInput(callback) {
+    if (!this.db || !this.inputPath) return null;
+    return this.db.watch(this.inputPath, (data) => {
+      if (data && typeof data === "object" && "command" in data) {
+        callback(data.command);
+      }
+    });
+  }
+};
+function createTerminalAdapter(options) {
+  return new TerminalAdapter(options);
+}
+async function runTerminalCommand(nodeId, command, options) {
+  const adapter = createTerminalAdapter({
+    nodeId,
+    cwd: options?.cwd,
+    env: options?.env,
+    db: options?.db,
+    executor: options?.executor
+  });
+  return adapter.executeCommand(command);
+}
+function createMockExecutor(responses) {
+  return async (command) => {
+    const response = responses[command] || responses["*"] || {
+      output: `Mock output for: ${command}`,
+      exitCode: 0
+    };
+    return response;
+  };
+}
+
+export {
+  TerminalAdapter,
+  createTerminalAdapter,
+  runTerminalCommand,
+  createMockExecutor
+};

package/dist/node/chunk-QGM4M3NI.js

@@ -0,0 +1,37 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};