joonecli 0.1.1 → 0.2.0

package/src/sandbox/manager.ts

@@ -1,239 +0,0 @@
-import { Sandbox as E2BSandbox } from "e2b";
-import { Sandbox as OSandbox, ConnectionConfig } from "@alibaba-group/opensandbox";
-
-/**
- * Result of a command execution in the sandbox.
- */
-export interface CommandResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-
-/**
- * Options for creating a SandboxManager.
- */
-export interface SandboxManagerOptions {
-  /** E2B API key. If not provided, reads from E2B_API_KEY env var. */
-  apiKey?: string;
-  /** OpenSandbox API key for the fallback. If not provided, reads from OPENSANDBOX_API_KEY env var. */
-  openSandboxApiKey?: string;
-  /** OpenSandbox API domain connection string. Defaults to localhost:8080. */
-  openSandboxDomain?: string;
-  /** Sandbox template to use. Defaults to E2B's base template. */
-  template?: string;
-  /** Sandbox timeout in milliseconds. Defaults to 5 minutes. */
-  timeoutMs?: number;
-}
-
-/**
- * Unifies E2B and OpenSandbox under a single interface.
- */
-interface ISandboxWrapper {
-  kill(): Promise<void>;
-  exec(command: string): Promise<CommandResult>;
-  uploadFile(path: string, content: string): Promise<void>;
-  getInternalInstance(): E2BSandbox | OSandbox;
-  getId(): string;
-  getProviderName(): "e2b" | "opensandbox";
-}
-
-class E2BSandboxWrapper implements ISandboxWrapper {
-  constructor(private sandbox: E2BSandbox) {}
-
-  async kill(): Promise<void> {
-    await this.sandbox.kill();
-  }
-
-  async exec(command: string): Promise<CommandResult> {
-    const result = await this.sandbox.commands.run(command);
-    return {
-      stdout: result.stdout,
-      stderr: result.stderr,
-      exitCode: result.exitCode,
-    };
-  }
-
-  async uploadFile(path: string, content: string): Promise<void> {
-    await this.sandbox.files.write(path, content);
-  }
-
-  getInternalInstance(): E2BSandbox {
-    return this.sandbox;
-  }
-
-  getId(): string {
-    return this.sandbox.sandboxId;
-  }
-
-  getProviderName(): "e2b" | "opensandbox" {
-    return "e2b";
-  }
-}
-
-class OpenSandboxWrapper implements ISandboxWrapper {
-  constructor(private sandbox: OSandbox) {}
-
-  async kill(): Promise<void> {
-    await this.sandbox.kill();
-  }
-
-  async exec(command: string): Promise<CommandResult> {
-    const execution = await this.sandbox.commands.run(command);
-    
-    // Process logs. OpenSandbox separates output into arrays of messages.
-    const stdout = execution.logs.stdout.map(m => m.text).join("");
-    const stderr = execution.logs.stderr.map(m => m.text).join("");
-    
-    // If there is an error block on the execution response, it means it failed.
-    const exitCode = execution.error ? 1 : 0;
-
-    return { stdout, stderr, exitCode };
-  }
-
-  async uploadFile(path: string, content: string): Promise<void> {
-    await this.sandbox.files.writeFiles([{
-        path,
-        data: content,
-        mode: 0o644
-    }]);
-  }
-
-  getInternalInstance(): OSandbox {
-    return this.sandbox;
-  }
-
-  getId(): string {
-    return this.sandbox.id || "opensandbox-local";
-  }
-
-  getProviderName(): "e2b" | "opensandbox" {
-    return "opensandbox";
-  }
-}
-
-/**
- * Manages the lifecycle of a cloud or local sandbox.
- * Attempts to use E2B first. If E2B fails (e.g., networking/auth error), 
- * it automatically falls back to OpenSandbox (local docker).
- */
-export class SandboxManager {
-  private wrapper: ISandboxWrapper | null = null;
-  private readonly e2bApiKey?: string;
-  private readonly osApiKey?: string;
-  private readonly osDomain?: string;
-  private readonly template?: string;
-  private readonly timeoutMs: number;
-
-  constructor(opts: SandboxManagerOptions = {}) {
-    this.e2bApiKey = opts.apiKey;
-    this.osApiKey = opts.openSandboxApiKey;
-    this.osDomain = opts.openSandboxDomain; // defaults via SDK if undefined
-    this.template = opts.template;
-    this.timeoutMs = opts.timeoutMs ?? 300_000; // 5 minutes default
-  }
-
-  /**
-   * Creates a new sandboxed execution environment.
-   * @returns The sandbox ID.
-   */
-  async create(): Promise<string> {
-    if (this.wrapper) {
-      await this.destroy();
-    }
-
-    // 1. Attempt E2B Primary Sandbox
-    try {
-      const createOpts = {
-        apiKey: this.e2bApiKey,
-        timeoutMs: this.timeoutMs,
-      };
-
-      const e2bInstance = this.template
-        ? await E2BSandbox.create(this.template, createOpts)
-        : await E2BSandbox.create(createOpts);
-
-      this.wrapper = new E2BSandboxWrapper(e2bInstance);
-      return this.wrapper.getId();
-
-    } catch (e2bError: any) {
-      console.warn(`[SandboxManager] E2B initialization failed: ${e2bError.message}. Falling back to OpenSandbox...`);
-
-      // 2. Attempt OpenSandbox Fallback
-      try {
-        const configOpts: { apiKey?: string; domain?: string } = {};
-        if (this.osApiKey) configOpts.apiKey = this.osApiKey;
-        if (this.osDomain) configOpts.domain = this.osDomain;
-        // else defaults locally to localhost:8080 without API key (Docker setup)
-
-        const config = new ConnectionConfig(configOpts);
-        const osInstance = await OSandbox.create({
-          connectionConfig: config,
-          image: this.template || "ubuntu:22.04", // Fallback to basic ubuntu if E2B template is specified
-          timeoutSeconds: Math.floor(this.timeoutMs / 1000)
-        });
-
-        this.wrapper = new OpenSandboxWrapper(osInstance);
-        return this.wrapper.getId();
-
-      } catch (osError: any) {
-        throw new Error(`CRITICAL: Both E2B and OpenSandbox initialization failed.\nE2B Error: ${e2bError.message}\nOpenSandbox Error: ${osError.message}`);
-      }
-    }
-  }
-
-  /**
-   * Destroys the active sandbox.
-   */
-  async destroy(): Promise<void> {
-    if (this.wrapper) {
-      await this.wrapper.kill();
-      this.wrapper = null;
-    }
-  }
-
-  /**
-   * Returns whether a sandbox is currently active.
-   */
-  isActive(): boolean {
-    return this.wrapper !== null;
-  }
-
-  /**
-   * Executes a shell command in the sandbox.
-   *
-   * @param command The shell command to run.
-   * @returns The command result (stdout, stderr, exitCode).
-   * @throws If the sandbox is not active.
-   */
-  async exec(command: string): Promise<CommandResult> {
-    if (!this.wrapper) {
-      throw new Error("Sandbox is not active. Call create() before exec().");
-    }
-    return await this.wrapper.exec(command);
-  }
-
-  /**
-   * Uploads a file to the sandbox filesystem.
-   *
-   * @param filePath Absolute path inside the sandbox (e.g., "/workspace/src/foo.ts").
-   * @param content File content as a string.
-   */
-  async uploadFile(filePath: string, content: string): Promise<void> {
-    if (!this.wrapper) {
-      throw new Error("Sandbox is not active. Call create() before uploadFile().");
-    }
-    await this.wrapper.uploadFile(filePath, content);
-  }
-
-  /**
-   * Returns the underlying E2B or OpenSandbox instance for advanced operations.
-   * @throws If the sandbox is not active.
-   */
-  getSandbox(): E2BSandbox | OSandbox {
-    if (!this.wrapper) {
-      throw new Error("Sandbox is not active.");
-    }
-    return this.wrapper.getInternalInstance();
-  }
-}

package/src/sandbox/sync.ts

@@ -1,157 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { SandboxManager } from "./manager.js";
-
-/**
- * Tracks file changes on the host and syncs them to the sandbox.
- *
- * Strategy: Upload-on-execute.
- * Before each sandbox command, only changed files are uploaded.
- */
-export class FileSync {
-  /** Files that have been modified since the last sync. */
-  private dirtyFiles = new Map<string, string>(); // hostPath → sandboxPath
-
-  /** The base directory on the host that maps to /workspace in sandbox. */
-  private readonly projectRoot: string;
-
-  /** The base path inside the sandbox. */
-  private readonly sandboxRoot: string;
-
-  constructor(projectRoot: string, sandboxRoot: string = "/workspace") {
-    this.projectRoot = projectRoot;
-    this.sandboxRoot = sandboxRoot;
-  }
-
-  /**
-   * Mark a file as dirty (changed on host, needs sync to sandbox).
-   *
-   * @param hostPath Absolute path on the host filesystem.
-   */
-  markDirty(hostPath: string): void {
-    const relative = path.relative(this.projectRoot, hostPath);
-    const sandboxPath = path.posix.join(this.sandboxRoot, relative.replace(/\\/g, "/"));
-    this.dirtyFiles.set(hostPath, sandboxPath);
-  }
-
-  /**
-   * Returns the number of files pending sync.
-   */
-  pendingCount(): number {
-    return this.dirtyFiles.size;
-  }
-
-  /**
-   * Syncs all dirty files to the sandbox.
-   * Reads each file from the host and uploads it to the sandbox.
-   *
-   * @param sandbox The active SandboxManager.
-   * @returns Number of files synced.
-   */
-  async syncToSandbox(sandbox: SandboxManager): Promise<number> {
-    let synced = 0;
-
-    for (const [hostPath, sandboxPath] of this.dirtyFiles) {
-      try {
-        const content = fs.readFileSync(hostPath, "utf-8");
-        await sandbox.uploadFile(sandboxPath, content);
-        synced++;
-      } catch (error: any) {
-        if (error.code === "ENOENT") {
-          // File was deleted from the host before it could be synced.
-          // We safely ignore this to prevent crashing the sync loop.
-        } else {
-          console.error(`Error reading ${hostPath} for sync:`, error.message);
-        }
-      }
-    }
-
-    this.dirtyFiles.clear();
-    return synced;
-  }
-
-  /**
-   * Performs an initial full sync of the project directory.
-   * Uploads all files (excluding node_modules, .git, dist).
-   *
-   * @param sandbox The active SandboxManager.
-   * @returns Number of files synced.
-   */
-  async initialSync(sandbox: SandboxManager): Promise<number> {
-    const EXCLUDE_DIRS = new Set(["node_modules", ".git", "dist", ".next", "__pycache__"]);
-    let synced = 0;
-
-    const walkDir = (dir: string) => {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-
-        if (entry.isDirectory()) {
-          if (!EXCLUDE_DIRS.has(entry.name)) {
-            walkDir(fullPath);
-          }
-        } else if (entry.isFile()) {
-          this.markDirty(fullPath);
-        }
-      }
-    };
-
-    walkDir(this.projectRoot);
-    synced = await this.syncToSandbox(sandbox);
-    return synced;
-  }
-
-  /**
-   * Syncs user-level skill directories into the sandbox.
-   * Skills from `~/.joone/skills/` and `~/.agents/skills/` are uploaded
-   * into `/workspace/.joone/skills/` so they are available for agent execution.
-   *
-   * @param sandbox The active SandboxManager.
-   * @param skillPaths Absolute host paths to skill directories to sync.
-   * @returns Number of files synced.
-   */
-  async syncSkillsToSandbox(
-    sandbox: SandboxManager,
-    skillPaths: { path: string; source: "project" | "user" }[]
-  ): Promise<number> {
-    let synced = 0;
-
-    for (const { path: skillDir, source } of skillPaths) {
-      // Only sync user-level skills (project-level are already in projectRoot)
-      if (source !== "user") continue;
-      if (!fs.existsSync(skillDir)) continue;
-
-      const walkSkillDir = (dir: string) => {
-        let entries: fs.Dirent[];
-        try {
-          entries = fs.readdirSync(dir, { withFileTypes: true });
-        } catch {
-          return;
-        }
-
-        for (const entry of entries) {
-          const fullPath = path.join(dir, entry.name);
-
-          if (entry.isDirectory()) {
-            walkSkillDir(fullPath);
-          } else if (entry.isFile()) {
-            const relative = path.relative(skillDir, fullPath);
-            const sandboxPath = path.posix.join(
-              this.sandboxRoot,
-              ".joone",
-              "skills",
-              relative.replace(/\\/g, "/")
-            );
-            this.dirtyFiles.set(fullPath, sandboxPath);
-          }
-        }
-      };
-
-      walkSkillDir(skillDir);
-    }
-
-    synced = await this.syncToSandbox(sandbox);
-    return synced;
-  }
-}

package/src/skills/loader.ts

@@ -1,143 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { SkillMeta } from "./types.js";
-
-/**
- * SkillLoader — discovers and loads skills from multiple directories.
- *
- * Discovery paths (priority order — project overrides user):
- * 1. Project root: ./skills/, ./.agents/skills/, ./.agent/skills/
- * 2. User home: ~/.joone/skills/, ~/.agents/skills/
- *
- * On Windows, ~ resolves to %USERPROFILE%.
- *
- * Skills are folders containing a SKILL.md with YAML frontmatter:
- * ---
- * name: my-skill
- * description: What this skill does
- * ---
- * ## Instructions
- * ...
- */
-export class SkillLoader {
-  private projectRoot: string;
-  private userHome: string;
-  private cachedSkills: SkillMeta[] | null = null;
-
-  constructor(projectRoot?: string, userHome?: string) {
-    this.projectRoot = projectRoot ?? process.cwd();
-    this.userHome = userHome ?? os.homedir();
-  }
-
-  /**
-   * Returns all skill discovery directories in priority order.
-   * Project-level directories come first (higher priority).
-   */
-  getDiscoveryPaths(): { path: string; source: "project" | "user" }[] {
-    const home = this.userHome;
-
-    return [
-      // Project-level (highest priority)
-      { path: path.join(this.projectRoot, "skills"), source: "project" as const },
-      { path: path.join(this.projectRoot, ".agents", "skills"), source: "project" as const },
-      { path: path.join(this.projectRoot, ".agent", "skills"), source: "project" as const },
-      // User-level
-      { path: path.join(home, ".joone", "skills"), source: "user" as const },
-      { path: path.join(home, ".agents", "skills"), source: "user" as const },
-    ];
-  }
-
-  /**
-   * Parses YAML frontmatter from a SKILL.md content string.
-   * Simple parser — handles `name:` and `description:` fields.
-   */
-  parseFrontmatter(content: string): { name?: string; description?: string } {
-    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
-    if (!match) return {};
-
-    const yaml = match[1];
-    const nameMatch = yaml.match(/^name:\s*(.+)$/m);
-    const descMatch = yaml.match(/^description:\s*(.+)$/m);
-
-    return {
-      name: nameMatch?.[1]?.trim(),
-      description: descMatch?.[1]?.trim(),
-    };
-  }
-
-  /**
-   * Discovers all available skills from all discovery paths.
-   * Deduplicates by name — project-level skills override user-level.
-   * Results are cached per session.
-   */
-  discoverSkills(): SkillMeta[] {
-    if (this.cachedSkills) return this.cachedSkills;
-
-    const skills = new Map<string, SkillMeta>();
-    const paths = this.getDiscoveryPaths();
-
-    for (const { path: dir, source } of paths) {
-      if (!fs.existsSync(dir)) continue;
-
-      let entries: fs.Dirent[];
-      try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-
-        const skillMdPath = path.join(dir, entry.name, "SKILL.md");
-        if (!fs.existsSync(skillMdPath)) continue;
-
-        try {
-          const content = fs.readFileSync(skillMdPath, "utf-8");
-          const frontmatter = this.parseFrontmatter(content);
-
-          const name = frontmatter.name || entry.name;
-
-          // Only add if not already found (project overrides user)
-          if (!skills.has(name)) {
-            skills.set(name, {
-              name,
-              description: frontmatter.description || `Skill: ${name}`,
-              path: skillMdPath,
-              source,
-            });
-          }
-        } catch {
-          // Skip unreadable skills
-        }
-      }
-    }
-
-    this.cachedSkills = Array.from(skills.values());
-    return this.cachedSkills;
-  }
-
-  /**
-   * Loads the full content of a specific skill's SKILL.md.
-   * Returns undefined if the skill is not found.
-   */
-  loadSkill(name: string): string | undefined {
-    const skills = this.discoverSkills();
-    const skill = skills.find((s) => s.name === name);
-    if (!skill) return undefined;
-
-    try {
-      return fs.readFileSync(skill.path, "utf-8");
-    } catch {
-      return undefined;
-    }
-  }
-
-  /**
-   * Clears the cached skills. Call when skills directory contents may have changed.
-   */
-  clearCache(): void {
-    this.cachedSkills = null;
-  }
-}

package/src/skills/tools.ts

@@ -1,99 +0,0 @@
-import { DynamicToolInterface, ToolResult } from "../tools/index.js";
-import { SkillLoader } from "./loader.js";
-
-// ─── Shared SkillLoader instance ──────────────────────────────────────────────
-
-let _loader: SkillLoader | null = null;
-
-export function bindSkillLoader(loader: SkillLoader): void {
-  _loader = loader;
-}
-
-function getLoader(): SkillLoader {
-  if (!_loader) {
-    _loader = new SkillLoader();
-  }
-  return _loader;
-}
-
-// ─── SearchSkillsTool ───────────────────────────────────────────────────────────
-
-export const SearchSkillsTool: DynamicToolInterface = {
-  name: "search_skills",
-  description:
-    "Search for available skills. Skills provide specialized instructions for specific tasks " +
-    "(e.g., deployment workflows, testing strategies, coding patterns).",
-  schema: {
-    type: "object",
-    properties: {
-      query: {
-        type: "string",
-        description:
-          "Search query to match against skill names and descriptions (optional — omit to list all)",
-      },
-    },
-  },
-  execute: async (args?: { query?: string }): Promise<ToolResult> => {
-    const loader = getLoader();
-    let skills = loader.discoverSkills();
-
-    if (args?.query) {
-      const q = args.query.toLowerCase();
-      skills = skills.filter(
-        (s) =>
-          s.name.toLowerCase().includes(q) ||
-          s.description.toLowerCase().includes(q)
-      );
-    }
-
-    if (skills.length === 0) {
-      return {
-        content: args?.query
-          ? `No skills found matching "${args.query}".`
-          : "No skills found. Create a skill by adding a folder with SKILL.md to ./skills/ or ~/.joone/skills/."
-      };
-    }
-
-    const list = skills
-      .map((s) => `- **${s.name}** (${s.source}): ${s.description}`)
-      .join("\n");
-
-    return {
-      content:
-        `Found ${skills.length} skill(s):\n${list}\n\n` +
-        `To load a skill, call \`load_skill\` with the skill name.`
-    };
-  },
-};
-
-// ─── LoadSkillTool ──────────────────────────────────────────────────────────────
-
-export const LoadSkillTool: DynamicToolInterface = {
-  name: "load_skill",
-  description:
-    "Loads a specific skill's full instructions (SKILL.md content). " +
-    "Use search_skills first to discover available skills.",
-  schema: {
-    type: "object",
-    properties: {
-      name: {
-        type: "string",
-        description: "The name of the skill to load",
-      },
-    },
-    required: ["name"],
-  },
-  execute: async (args: { name: string }): Promise<ToolResult> => {
-    const loader = getLoader();
-    const content = loader.loadSkill(args.name);
-
-    if (!content) {
-      return {
-        content: `Error: Skill "${args.name}" not found. Use search_skills to see available skills.`,
-        isError: true
-      };
-    }
-
-    return { content };
-  },
-};

package/src/skills/types.ts

@@ -1,13 +0,0 @@
-/**
- * Skill metadata parsed from SKILL.md YAML frontmatter.
- */
-export interface SkillMeta {
-  /** Human-readable name (from YAML `name` field). */
-  name: string;
-  /** Short description (from YAML `description` field). */
-  description: string;
-  /** Absolute path to the SKILL.md file. */
-  path: string;
-  /** Where this skill was discovered. */
-  source: "project" | "user";
-}