playnex-cli 0.1.0

package/src/commands/login.js

@@ -0,0 +1,59 @@
+import axios from "axios";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { saveConfig } from "../services/config.js";
+
+const API_BASE = "https://playnex.app";
+
+export default async function login() {
+  console.log(chalk.cyan("\nPlaynex Login\n"));
+
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "email",
+      message: "Email:"
+    },
+    {
+      type: "password",
+      name: "password",
+      message: "Password:"
+    }
+  ]);
+
+  try {
+    const res = await axios.post(`${API_BASE}/cli/login`, {
+      email: answers.email,
+      password: answers.password
+    });
+
+    if (!res.data || !res.data.token) {
+      console.log(chalk.red("Login failed: no token returned."));
+      return;
+    }
+
+    saveConfig({ token: res.data.token });
+
+    console.log(chalk.green("\n✔ Login successful!\n"));
+  } catch (err) {
+    console.log(chalk.red("\nLogin failed.\n"));
+
+    if (err.response) {
+      console.log(chalk.red(`Server responded with ${err.response.status}`));
+
+      if (err.response.data?.forcePasswordChange) {
+        console.log(
+          chalk.yellow(
+            "\nYour account requires a password change before continuing."
+          )
+        );
+      }
+
+      if (err.response.data?.error) {
+        console.log(chalk.red(err.response.data.error));
+      }
+    } else {
+      console.log(err.message);
+    }
+  }
+}

package/src/commands/scheduler/scheduler.js

@@ -0,0 +1,154 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+import { spawn } from "child_process";
+
+/**
+ * Agent Scheduler
+ * Allows agents to run automatically on intervals.
+ *
+ * Commands:
+ *   playnex scheduler add <agent> <interval>
+ *   playnex scheduler list
+ *   playnex scheduler remove <id>
+ *   playnex scheduler run   (daemon)
+ */
+
+const WORKSPACE_DIR = path.join(os.homedir(), ".playnex", "workspace");
+const SCHEDULE_FILE = path.join(WORKSPACE_DIR, "schedule.json");
+
+// Ensure schedule file exists
+function ensureScheduleFile() {
+  if (!fs.existsSync(WORKSPACE_DIR)) {
+    fs.mkdirSync(WORKSPACE_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(SCHEDULE_FILE)) {
+    fs.writeFileSync(SCHEDULE_FILE, JSON.stringify([], null, 2), "utf8");
+  }
+}
+
+function loadSchedule() {
+  ensureScheduleFile();
+  return JSON.parse(fs.readFileSync(SCHEDULE_FILE, "utf8"));
+}
+
+function saveSchedule(data) {
+  fs.writeFileSync(SCHEDULE_FILE, JSON.stringify(data, null, 2), "utf8");
+}
+
+// ---------------------------------------------
+// Add a scheduled agent
+// ---------------------------------------------
+export function schedulerAdd(agent, interval) {
+  ensureScheduleFile();
+
+  const schedule = loadSchedule();
+
+  const id = Date.now().toString();
+  schedule.push({
+    id,
+    agent,
+    interval,
+    lastRun: 0
+  });
+
+  saveSchedule(schedule);
+
+  console.log(chalk.green(`✔ Scheduled agent '${agent}' every '${interval}' (id: ${id})`));
+}
+
+// ---------------------------------------------
+// List scheduled agents
+// ---------------------------------------------
+export function schedulerList() {
+  ensureScheduleFile();
+
+  const schedule = loadSchedule();
+
+  if (schedule.length === 0) {
+    console.log(chalk.yellow("No scheduled agents."));
+    return;
+  }
+
+  console.log(chalk.cyan("\nScheduled Agents:\n"));
+  schedule.forEach(item => {
+    console.log(`ID: ${item.id}`);
+    console.log(`Agent: ${item.agent}`);
+    console.log(`Interval: ${item.interval}`);
+    console.log(`Last Run: ${item.lastRun ? new Date(item.lastRun).toLocaleString() : "Never"}`);
+    console.log("");
+  });
+}
+
+// ---------------------------------------------
+// Remove a scheduled agent
+// ---------------------------------------------
+export function schedulerRemove(id) {
+  ensureScheduleFile();
+
+  let schedule = loadSchedule();
+  const before = schedule.length;
+
+  schedule = schedule.filter(item => item.id !== id);
+
+  saveSchedule(schedule);
+
+  if (schedule.length < before) {
+    console.log(chalk.green(`✔ Removed scheduled task ${id}`));
+  } else {
+    console.log(chalk.red(`No scheduled task found with id ${id}`));
+  }
+}
+
+// ---------------------------------------------
+// Run scheduler daemon
+// ---------------------------------------------
+export function schedulerRun() {
+  ensureScheduleFile();
+
+  console.log(chalk.cyan("\nRunning scheduler daemon...\n"));
+
+  setInterval(() => {
+    const schedule = loadSchedule();
+    const now = Date.now();
+
+    schedule.forEach(item => {
+      const ms = parseInterval(item.interval);
+
+      if (!ms) return;
+
+      if (now - item.lastRun >= ms) {
+        console.log(chalk.green(`\n⏱ Running agent '${item.agent}' (id: ${item.id})`));
+
+        // Run agent in a child process
+        const child = spawn("playnex", ["agent", "run", item.agent], {
+          stdio: "inherit",
+          shell: true
+        });
+
+        item.lastRun = now;
+        saveSchedule(schedule);
+      }
+    });
+  }, 5000); // check every 5 seconds
+}
+
+// ---------------------------------------------
+// Parse interval strings like "1h", "30m", "10s"
+// ---------------------------------------------
+function parseInterval(str) {
+  const match = str.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) return null;
+
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+
+  switch (unit) {
+    case "s": return value * 1000;
+    case "m": return value * 60 * 1000;
+    case "h": return value * 60 * 60 * 1000;
+    case "d": return value * 24 * 60 * 60 * 1000;
+    default: return null;
+  }
+}

package/src/commands/tools/registry.js

@@ -0,0 +1,121 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+
+/**
+ * Tool Registry
+ * Stores metadata about tools:
+ * - name
+ * - description
+ * - parameters
+ * - version
+ * - author
+ * - capabilities
+ * - safety flags
+ */
+
+const WORKSPACE_DIR = path.join(os.homedir(), ".playnex", "workspace");
+const REGISTRY_FILE = path.join(WORKSPACE_DIR, "tool-registry.json");
+
+// Ensure registry file exists
+function ensureRegistry() {
+  if (!fs.existsSync(WORKSPACE_DIR)) {
+    fs.mkdirSync(WORKSPACE_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(REGISTRY_FILE)) {
+    fs.writeFileSync(REGISTRY_FILE, JSON.stringify([], null, 2), "utf8");
+  }
+}
+
+function loadRegistry() {
+  ensureRegistry();
+  return JSON.parse(fs.readFileSync(REGISTRY_FILE, "utf8"));
+}
+
+function saveRegistry(data) {
+  fs.writeFileSync(REGISTRY_FILE, JSON.stringify(data, null, 2), "utf8");
+}
+
+// ---------------------------------------------
+// Register a tool
+// ---------------------------------------------
+export function registerTool(toolName) {
+  ensureRegistry();
+
+  const registry = loadRegistry();
+
+  const toolPath = path.join(process.cwd(), "src", "tools", `${toolName}.js`);
+  if (!fs.existsSync(toolPath)) {
+    console.log(chalk.red(`Tool '${toolName}' does not exist in src/tools.`));
+    process.exit(1);
+  }
+
+  // Basic metadata scaffold
+  const entry = {
+    name: toolName,
+    description: "",
+    version: "1.0.0",
+    author: "local",
+    parameters: [],
+    capabilities: [],
+    requiresAuth: false,
+    safeForAutonomy: true,
+    registeredAt: new Date().toISOString()
+  };
+
+  // Avoid duplicates
+  if (registry.some(t => t.name === toolName)) {
+    console.log(chalk.yellow(`Tool '${toolName}' is already registered.`));
+    return;
+  }
+
+  registry.push(entry);
+  saveRegistry(registry);
+
+  console.log(chalk.green(`✔ Registered tool '${toolName}' in tool registry.`));
+}
+
+// ---------------------------------------------
+// List all tools in registry
+// ---------------------------------------------
+export function listTools() {
+  ensureRegistry();
+
+  const registry = loadRegistry();
+
+  if (registry.length === 0) {
+    console.log(chalk.yellow("No tools registered."));
+    return;
+  }
+
+  console.log(chalk.cyan("\nRegistered Tools:\n"));
+  registry.forEach(t => {
+    console.log(`- ${t.name} (v${t.version})`);
+  });
+}
+
+// ---------------------------------------------
+// Show detailed info for a tool
+// ---------------------------------------------
+export function toolInfo(toolName) {
+  ensureRegistry();
+
+  const registry = loadRegistry();
+  const tool = registry.find(t => t.name === toolName);
+
+  if (!tool) {
+    console.log(chalk.red(`Tool '${toolName}' not found in registry.`));
+    return;
+  }
+
+  console.log(chalk.cyan(`\nTool: ${tool.name}\n`));
+  console.log(`Description: ${tool.description || "(none)"}`);
+  console.log(`Version: ${tool.version}`);
+  console.log(`Author: ${tool.author}`);
+  console.log(`Parameters: ${tool.parameters.join(", ") || "(none)"}`);
+  console.log(`Capabilities: ${tool.capabilities.join(", ") || "(none)"}`);
+  console.log(`Requires Auth: ${tool.requiresAuth}`);
+  console.log(`Safe for Autonomy: ${tool.safeForAutonomy}`);
+  console.log(`Registered At: ${tool.registeredAt}\n`);
+}

package/src/commands/workspace/sync.js

@@ -0,0 +1,98 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+import axios from "axios";
+import { loadConfig } from "../../services/config.js";
+
+/**
+ * workspace sync
+ * Syncs agents, capsules, and tool metadata from cloud → local.
+ */
+
+const API_BASE = "https://playnex.app";
+
+export default async function workspaceSync() {
+  const config = loadConfig();
+
+  if (!config.token) {
+    console.log(chalk.red("You must log in first."));
+    console.log("Run: playnex login");
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan("\nSyncing Playnex workspace..."));
+
+  const WORKSPACE_DIR = path.join(os.homedir(), ".playnex", "workspace");
+  const AGENTS_DIR = path.join(WORKSPACE_DIR, "agents");
+  const CAPSULES_DIR = path.join(WORKSPACE_DIR, "capsules");
+  const TOOLS_DIR = path.join(WORKSPACE_DIR, "tools");
+
+  // Ensure directories exist
+  [WORKSPACE_DIR, AGENTS_DIR, CAPSULES_DIR, TOOLS_DIR].forEach(dir => {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  });
+
+  // -------------------------------
+  // Sync Agents
+  // -------------------------------
+  console.log(chalk.gray("Fetching agents..."));
+
+  const agentsRes = await axios.get(
+    `${API_BASE}/agents/all`,
+    {
+      headers: { Authorization: `Bearer ${config.token}` }
+    }
+  );
+
+  const agents = agentsRes.data || [];
+
+  agents.forEach(agent => {
+    const file = path.join(AGENTS_DIR, `${agent.name}.json`);
+    fs.writeFileSync(file, JSON.stringify(agent, null, 2), "utf8");
+  });
+
+  console.log(chalk.green(`✔ Synced ${agents.length} agents.`));
+
+  // -------------------------------
+  // Sync Capsules
+  // -------------------------------
+  console.log(chalk.gray("Fetching capsules..."));
+
+  const capsulesRes = await axios.get(
+    `${API_BASE}/capsules/all`,
+    {
+      headers: { Authorization: `Bearer ${config.token}` }
+    }
+  );
+
+  const capsules = capsulesRes.data || [];
+
+  capsules.forEach(capsule => {
+    const file = path.join(CAPSULES_DIR, `${capsule.id}.json`);
+    fs.writeFileSync(file, JSON.stringify(capsule, null, 2), "utf8");
+  });
+
+  console.log(chalk.green(`✔ Synced ${capsules.length} capsules.`));
+
+  // -------------------------------
+  // Sync Tool Metadata
+  // -------------------------------
+  console.log(chalk.gray("Fetching tool metadata..."));
+
+  const toolsRes = await axios.get(
+    `${API_BASE}/tools/all`,
+    {
+      headers: { Authorization: `Bearer ${config.token}` }
+    }
+  );
+
+  const tools = toolsRes.data || [];
+
+  const toolsFile = path.join(TOOLS_DIR, "tools.json");
+  fs.writeFileSync(toolsFile, JSON.stringify(tools, null, 2), "utf8");
+
+  console.log(chalk.green(`✔ Synced ${tools.length} tools.`));
+
+  console.log(chalk.green("\n✔ Workspace sync complete.\n"));
+}

package/src/services/agents.js

@@ -0,0 +1,2 @@
+import fs from "fs";
+export const test = true;

package/src/services/config.js

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const CONFIG_DIR = path.join(os.homedir(), '.playnex');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+
+export function loadConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return {};
+  }
+  const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export function saveConfig(data) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(data, null, 2), 'utf8');
+}
+
+export function updateConfig(patch) {
+  const current = loadConfig();
+  const next = { ...current, ...patch };
+  saveConfig(next);
+  return next;
+}

package/src/tools/browser.js

@@ -0,0 +1,59 @@
+import axios from "axios";
+import chalk from "chalk";
+
+/**
+ * browser tool
+ * Allows agents to fetch and read web pages.
+ *
+ * Expected JSON from agent:
+ * {
+ *   "tool": "browser",
+ *   "input": {
+ *     "url": "https://example.com"
+ *   }
+ * }
+ */
+
+export default async function browser(agent, input) {
+  if (!input || typeof input !== "object") {
+    console.log(chalk.red("browser: invalid input. Expected { url }."));
+    return "browser: invalid input.";
+  }
+
+  const { url } = input;
+
+  if (!url || typeof url !== "string") {
+    console.log(chalk.red("browser: missing or invalid url."));
+    return "browser: missing or invalid url.";
+  }
+
+  console.log(chalk.gray(`Fetching URL: ${url}`));
+
+  try {
+    const res = await axios.get(url, {
+      timeout: 15000,
+      maxContentLength: 1024 * 1024 * 2 // 2MB safety limit
+    });
+
+    const contentType = res.headers["content-type"] || "";
+
+    // Only return text-based content
+    if (!contentType.includes("text") && !contentType.includes("json")) {
+      console.log(chalk.yellow("browser: URL does not contain readable text content."));
+      return "browser: URL does not contain readable text content.";
+    }
+
+    const text = res.data;
+
+    console.log(chalk.green("✔ Page fetched successfully."));
+
+    // Return first 5000 chars to avoid overload
+    return typeof text === "string"
+      ? text.slice(0, 5000)
+      : JSON.stringify(text).slice(0, 5000);
+
+  } catch (err) {
+    console.log(chalk.red("browser: failed to fetch URL."));
+    return `browser: error fetching URL: ${err.message}`;
+  }
+}

package/src/tools/capsule-append.js

@@ -0,0 +1,67 @@
+import axios from "axios";
+import chalk from "chalk";
+import { loadConfig } from "../services/config.js";
+
+/**
+ * capsule-append tool
+ * Allows agents to append content to an existing capsule.
+ *
+ * Expected JSON from agent:
+ * {
+ *   "tool": "capsule-append",
+ *   "input": {
+ *     "id": "123",
+ *     "content": "Additional text to append."
+ *   }
+ * }
+ */
+
+const API_BASE = "https://playnex.app";
+
+export default async function capsuleAppend(agent, input) {
+  const config = loadConfig();
+
+  if (!config.token) {
+    console.log(chalk.red("You must log in first."));
+    console.log("Run: playnex login");
+    process.exit(1);
+  }
+
+  if (!input || typeof input !== "object") {
+    console.log(chalk.red("capsule-append: invalid input. Expected { id, content }."));
+    return "capsule-append: invalid input.";
+  }
+
+  const { id, content } = input;
+
+  if (!id || !content) {
+    console.log(chalk.red("capsule-append: missing id or content."));
+    return "capsule-append: missing id or content.";
+  }
+
+  console.log(chalk.gray(`Appending to capsule ${id}...`));
+
+  const payload = {
+    id,
+    append: content
+  };
+
+  const res = await axios.post(
+    `${API_BASE}/capsules/append`,
+    payload,
+    {
+      headers: {
+        Authorization: `Bearer ${config.token}`
+      }
+    }
+  );
+
+  if (!res.data || !res.data.updated) {
+    console.log(chalk.red("Failed to append to capsule."));
+    return "Failed to append to capsule.";
+  }
+
+  console.log(chalk.green(`✔ Capsule ${id} updated successfully.`));
+
+  return `Capsule ${id} updated: ${content}`;
+}

package/src/tools/capsule-search.js

@@ -0,0 +1,74 @@
+import axios from "axios";
+import chalk from "chalk";
+import { loadConfig } from "../services/config.js";
+
+/**
+ * capsule-search tool
+ * Allows agents to search across all capsules using keyword relevance.
+ *
+ * Expected JSON from agent:
+ * {
+ *   "tool": "capsule-search",
+ *   "input": "local-first agents"
+ * }
+ */
+
+const API_BASE = "https://playnex.app";
+
+export default async function capsuleSearch(agent, query) {
+  const config = loadConfig();
+
+  if (!config.token) {
+    console.log(chalk.red("You must log in first."));
+    console.log("Run: playnex login");
+    process.exit(1);
+  }
+
+  if (!query || typeof query !== "string") {
+    console.log(chalk.red("capsule-search: invalid input. Expected a search string."));
+    return "capsule-search: invalid input.";
+  }
+
+  console.log(chalk.gray(`Searching capsules for: '${query}'...`));
+
+  // Fetch all capsules
+  const res = await axios.get(
+    `${API_BASE}/capsules/all`,
+    {
+      headers: {
+        Authorization: `Bearer ${config.token}`
+      }
+    }
+  );
+
+  const capsules = res.data || [];
+
+  if (!Array.isArray(capsules) || capsules.length === 0) {
+    console.log(chalk.yellow("No capsules found."));
+    return "No capsules found.";
+  }
+
+  const terms = query.toLowerCase().split(" ");
+
+  // Score capsules by keyword overlap
+  const results = capsules
+    .map(c => {
+      const text = (c.title + " " + c.description).toLowerCase();
+      const score = terms.reduce((acc, word) => acc + (text.includes(word) ? 1 : 0), 0);
+      return { capsule: c, score };
+    })
+    .filter(r => r.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 5);
+
+  if (results.length === 0) {
+    console.log(chalk.yellow("No relevant capsules found."));
+    return "No relevant capsules found.";
+  }
+
+  console.log(chalk.green(`Found ${results.length} relevant capsules.`));
+
+  return results
+    .map(r => `[Capsule ${r.capsule.id}] ${r.capsule.title}: ${r.capsule.description}`)
+    .join("\\n\\n");
+}