octo-agent 0.11.2

data/lib/octo/default_skills/onboard/scripts/import_external_skills.rb

@@ -0,0 +1,413 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+
+# Import skills from external AI tool installations into ~/.octo/skills/.
+#
+# Supported sources:
+#   - OpenClaw: ~/.openclaw/skills/, ~/.openclaw/workspace/skills/,
+#               ~/.openclaw/workspace/.agents/skills/
+#
+# Each source is imported into a dedicated category subdirectory under ~/.octo/skills/,
+# e.g. ~/.octo/skills/openclaw-imports/<skill-name>/. This keeps imported skills
+# isolated from the user's own skills and makes the origin traceable.
+#
+# Usage: ruby import_external_skills.rb [--source <name>] [--dry-run] [--yes]
+#
+# Options:
+#   --source <name>          Import only from the named source (e.g. "openclaw").
+#                            Defaults to all supported sources.
+#   --dry-run                Preview what would be imported without making any changes.
+#   --yes                    Skip confirmation prompt and execute immediately.
+#
+# Exit codes:
+#   0 - success (including "nothing to import" case)
+#   1 - unexpected error
+
+# ---------------------------------------------------------------------------
+# Base class for a single-source importer
+# ---------------------------------------------------------------------------
+class ExternalSkillsImporter
+  # @param target_skills_dir [Pathname] ~/.octo/skills/
+  # @param category_subdir [String] subdirectory name used to group imported skills
+  # @param dry_run [Boolean] when true, only preview without making changes
+  def initialize(target_skills_dir:, category_subdir:, dry_run: false)
+    @target_skills_dir = target_skills_dir
+    @target_import_dir = target_skills_dir.join(category_subdir)
+    @dry_run           = dry_run
+    @imported          = []
+    @errors            = []
+  end
+
+  # Run the import for this source.
+  # @return [Integer] number of skills imported (or would be imported in dry-run mode)
+  def run
+    unless source_available?
+      puts "[INFO] #{source_label} not found - skipping."
+      return 0
+    end
+
+    skills = discover_skills
+    if skills.empty?
+      puts "[INFO] No #{source_label} skills found - nothing to import."
+      return 0
+    end
+
+    skills.each { |skill| process_skill(skill) }
+
+    @imported.size
+  end
+
+  # Errors encountered during this import run.
+  # @return [Array<String>]
+  def errors
+    @errors.dup
+  end
+
+  # Imported skill records for reporting.
+  # @return [Array<Hash>]
+  def imported
+    @imported.dup
+  end
+
+  # Human-readable name for this source (used in output messages).
+  # Subclasses must override.
+  # @return [String]
+  private def source_label
+    raise NotImplementedError
+  end
+
+  # Return true when the source root directory exists on this machine.
+  # Subclasses must override.
+  # @return [Boolean]
+  private def source_available?
+    raise NotImplementedError
+  end
+
+  # Discover all valid skill directories from the external source.
+  # Each element must be a Hash with at least: { name:, source_dir:, origin: }
+  # Subclasses must override.
+  # @return [Array<Hash>]
+  private def discover_skills
+    raise NotImplementedError
+  end
+
+  # Process a single skill: record it for preview, and copy if not in dry-run mode.
+  #
+  # @param skill [Hash] { name:, source_dir:, origin: }
+  private def process_skill(skill)
+    name       = skill[:name]
+    source_dir = Pathname.new(skill[:source_dir])
+    dest_dir   = @target_import_dir.join(name)
+
+    action = dest_dir.exist? ? 'updated' : 'imported'
+    description = read_description(source_dir.join('SKILL.md'))
+
+    @imported << {
+      name:        name,
+      action:      action,
+      description: description,
+      dest:        dest_dir,
+      source_dir:  source_dir,
+      origin:      skill[:origin]
+    }
+
+    return if @dry_run
+
+    copy_skill(name, source_dir, dest_dir, action)
+  rescue StandardError => e
+    @errors << "Failed to process '#{name}': #{e.message}"
+  end
+
+  # Copy a single skill directory into @target_import_dir.
+  # Existing destinations are removed first so re-running is idempotent.
+  #
+  # @param name [String]
+  # @param source_dir [Pathname]
+  # @param dest_dir [Pathname]
+  # @param action [String] 'imported' or 'updated'
+  private def copy_skill(name, source_dir, dest_dir, action)
+    FileUtils.mkdir_p(@target_import_dir)
+    FileUtils.rm_rf(dest_dir) if dest_dir.exist?
+    FileUtils.mkdir_p(dest_dir)
+
+    # Copy all contents: SKILL.md, scripts/, assets/, etc.
+    source_dir.children.each { |child| FileUtils.cp_r(child, dest_dir) }
+  rescue StandardError => e
+    @errors << "Failed to import '#{name}': #{e.message}"
+  end
+
+  # Extract the description field from SKILL.md YAML frontmatter.
+  # @param skill_file [Pathname]
+  # @return [String]
+  private def read_description(skill_file)
+    return 'No description' unless skill_file.exist?
+
+    content = skill_file.read
+    return $1.strip if content =~ /\A---\s*\n.*?^description:\s*(.+)$/m
+
+    'No description'
+  rescue StandardError
+    'No description'
+  end
+end
+
+# ---------------------------------------------------------------------------
+# OpenClaw importer
+# ---------------------------------------------------------------------------
+class OpenClawImporter < ExternalSkillsImporter
+  SOURCE_NAME          = 'openclaw'
+  DEFAULT_OPENCLAW_DIR = File.join(Dir.home, '.openclaw')
+
+  # @param kwargs forwarded to ExternalSkillsImporter
+  def initialize(**kwargs)
+    super(category_subdir: 'openclaw-imports', **kwargs)
+    @openclaw_dir = Pathname.new(DEFAULT_OPENCLAW_DIR).expand_path
+  end
+
+  private def source_label
+    'OpenClaw (~/.openclaw)'
+  end
+
+  private def source_available?
+    openclaw_dirs.any?(&:exist?)
+  end
+
+  # Returns all directories that may contain OpenClaw skills.
+  # Each entry is a hash: { root: Pathname, layout: :flat }
+  #
+  # Mirrors the sources from hermes openclaw_to_hermes.py:
+  #   - ~/.openclaw/workspace/skills/             (workspace skills)
+  #   - ~/.openclaw/skills/                        (managed/shared skills)
+  #   - ~/.openclaw/workspace/.agents/skills/      (project-level shared skills)
+  #
+  # On WSL, also scans the Windows-native %USERPROFILE%\.openclaw directory.
+  private def source_dirs
+    openclaw_dirs.flat_map do |root|
+      [
+        root.join('workspace', 'skills'),
+        root.join('skills'),
+        root.join('workspace', '.agents', 'skills')
+      ]
+    end.select(&:exist?)
+  end
+
+  # All candidate OpenClaw root directories.
+  # On WSL, includes both ~/.openclaw and the Windows-native path.
+  private def openclaw_dirs
+    dirs = [@openclaw_dir]
+    win_home = windows_home
+    dirs << win_home.join('.openclaw') if win_home && win_home.join('.openclaw') != @openclaw_dir
+    dirs
+  end
+
+  # True when running inside WSL.
+  # Mirrors EnvironmentDetector#wsl? — reads /proc/version for "microsoft".
+  private def wsl?
+    return @wsl if defined?(@wsl)
+
+    @wsl = File.exist?('/proc/version') &&
+           File.read('/proc/version').downcase.include?('microsoft')
+  rescue StandardError
+    @wsl = false
+  end
+
+  # Resolve the Windows %USERPROFILE% as a WSL-accessible Pathname.
+  # Uses powershell.exe (standard in WSL) then wslpath for conversion,
+  # mirroring the approach in EnvironmentDetector#wsl_desktop_path.
+  # Returns nil when not on WSL or when the path cannot be resolved.
+  private def windows_home
+    return nil unless wsl?
+    return nil if `which powershell.exe 2>/dev/null`.strip.empty?
+
+    win_path = `powershell.exe -NoProfile -Command '$env:USERPROFILE' 2>/dev/null`.strip.tr("\r\n", '')
+    return nil if win_path.empty?
+
+    linux_path = `wslpath '#{win_path}' 2>/dev/null`.strip
+    return nil if linux_path.empty?
+
+    path = Pathname.new(linux_path)
+    path.exist? ? path : nil
+  rescue StandardError
+    nil
+  end
+
+  private def discover_skills
+    skills = []
+
+    source_dirs.each do |dir|
+      dir.children.select(&:directory?).each do |skill_dir|
+        next unless skill_dir.join('SKILL.md').exist?
+
+        skills << {
+          name:       skill_dir.basename.to_s,
+          source_dir: skill_dir,
+          origin:     dir.basename.to_s
+        }
+      end
+    end
+
+    skills.sort_by { |s| s[:name] }
+  end
+end
+
+# ---------------------------------------------------------------------------
+# Coordinator - runs all enabled importers and prints a combined report
+# ---------------------------------------------------------------------------
+class ExternalSkillsImportRunner
+  # Register new importer classes here to add support for more sources.
+  IMPORTERS = [OpenClawImporter].freeze
+  SOURCES   = IMPORTERS.map { |klass| klass::SOURCE_NAME }.freeze
+
+  # @param sources [Array<String>] subset of SOURCES to run; nil means all
+  # @param target_skills_dir [String]
+  # @param dry_run [Boolean] when true, only preview without making changes
+  # @param yes [Boolean] when true, skip confirmation prompt
+  def initialize(sources: nil,
+                 target_skills_dir: File.join(Dir.home, '.octo', 'skills'),
+                 dry_run: false,
+                 yes: false)
+    @sources           = (sources || SOURCES) & SOURCES
+    @target_skills_dir = Pathname.new(target_skills_dir).expand_path
+    @dry_run           = dry_run
+    @yes               = yes
+  end
+
+  def run
+    # In dry-run mode: collect plan and print preview only
+    if @dry_run
+      importers = build_importers(dry_run: true)
+      all_imported = []
+      importers.each { |i| i.run; all_imported.concat(i.imported) }
+      print_preview(all_imported, dry_run: true)
+      return all_imported.size
+    end
+
+    # Normal mode: collect plan first, show preview, then confirm
+    preview_importers = build_importers(dry_run: true)
+    all_preview = []
+    preview_importers.each { |i| i.run; all_preview.concat(i.imported) }
+
+    if all_preview.empty?
+      puts 'Nothing to import.'
+      return 0
+    end
+
+    print_preview(all_preview, dry_run: false)
+
+    unless @yes || confirm?
+      puts 'Import cancelled.'
+      return 0
+    end
+
+    # Execute the actual import
+    importers = build_importers(dry_run: false)
+    all_imported = []
+    all_errors   = []
+
+    importers.each do |importer|
+      importer.run
+      all_imported.concat(importer.imported)
+      all_errors.concat(importer.errors)
+    end
+
+    print_summary(all_imported, all_errors)
+    all_imported.size
+  end
+
+  private def build_importers(dry_run:)
+    common = { target_skills_dir: @target_skills_dir, dry_run: dry_run }
+
+    IMPORTERS
+      .select { |klass| @sources.include?(klass::SOURCE_NAME) }
+      .map { |klass| klass.new(**common) }
+  end
+
+  # Print a Hermes-style preview of what would be / will be imported.
+  # @param skills [Array<Hash>]
+  # @param dry_run [Boolean]
+  private def print_preview(skills, dry_run:)
+    if dry_run
+      puts 'Dry Run Results'
+      puts '  No files will be modified. This is a preview of what would happen.'
+    else
+      puts 'Import Preview'
+      puts '  The following skills will be imported/updated:'
+    end
+    puts
+
+    if skills.empty?
+      puts '  (nothing to import)'
+    else
+      label_width = skills.map { |s| s[:origin].length }.max || 0
+      skills.each do |s|
+        action_marker = s[:action] == 'updated' ? '~' : '✓'
+        puts "  #{action_marker} Would import:  #{s[:origin].ljust(label_width)}  →  #{s[:dest]}"
+      end
+    end
+
+    puts
+    puts "  Summary: #{skills.size} skill(s) would be #{dry_run ? 'imported' : 'imported/updated'}"
+    puts
+  end
+
+  # Print summary after actual import.
+  private def print_summary(imported, errors)
+    puts '=' * 60
+
+    if imported.empty? && errors.empty?
+      puts 'Nothing was imported.'
+    elsif imported.any?
+      puts "Import complete! #{imported.size} skill(s) ready:\n\n"
+      imported.each do |s|
+        action_label = s[:action] == 'updated' ? '[updated]' : '[new]'
+        puts "  #{action_label} #{s[:name]}"
+        puts "    #{s[:description]}"
+        puts "    -> #{s[:dest]}"
+        puts
+      end
+      puts 'Skills will be available automatically next time Octo starts.'
+    end
+
+    if errors.any?
+      puts 'Errors:'
+      errors.each { |e| puts "  - #{e}" }
+    end
+
+    puts '=' * 60
+  end
+
+  # Prompt user for confirmation.
+  # @return [Boolean]
+  private def confirm?
+    print 'Proceed with import? [y/N] '
+    $stdout.flush
+    answer = $stdin.gets&.strip&.downcase
+    answer == 'y' || answer == 'yes'
+  end
+end
+
+# -- Entry point ------------------------------------------------------------
+if __FILE__ == $PROGRAM_NAME
+  require 'optparse'
+
+  options = {}
+
+  OptionParser.new do |opts|
+    opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options]"
+    opts.on('--source NAME',
+            "Import only from NAME (e.g. openclaw). Supported: #{ExternalSkillsImportRunner::SOURCES.join(', ')}") do |name|
+      options[:sources] = [name]
+    end
+    opts.on('--dry-run', 'Preview what would be imported without making any changes.') do
+      options[:dry_run] = true
+    end
+    opts.on('--yes', '-y', 'Skip confirmation prompt and execute immediately.') do
+      options[:yes] = true
+    end
+  end.parse!
+
+  ExternalSkillsImportRunner.new(**options).run
+end

data/lib/octo/default_skills/onboard/scripts/install_builtin_skills.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+
+require_relative '../../skill-add/scripts/install_from_zip'
+
+class BuiltinSkillsInstaller
+  PRIMARY_HOST     = ENV.fetch('OCTO_LICENSE_SERVER', 'https://www.octo.com')
+  FALLBACK_HOST    = 'https://octo.up.railway.app'
+  API_HOSTS        = ENV['OCTO_LICENSE_SERVER'] ? [PRIMARY_HOST] : [PRIMARY_HOST, FALLBACK_HOST]
+  API_PATH         = '/api/v1/skills/builtin'
+  API_OPEN_TIMEOUT = 5
+  API_READ_TIMEOUT = 10
+
+  def initialize
+    @target_dir       = File.join(Dir.home, '.octo', 'skills')
+    @installed        = 0
+    @skipped_existing = 0
+    @attempted        = 0
+    @errors           = []
+  end
+
+  def run
+    skills = fetch_skill_list
+    if skills.nil? || skills.empty?
+      emit_summary
+      return
+    end
+
+    skills.each { |skill| install_one(skill) }
+  ensure
+    emit_summary
+  end
+
+  private def fetch_skill_list
+    API_HOSTS.each do |host|
+      begin
+        uri = URI.parse(host + API_PATH)
+        Net::HTTP.start(uri.host, uri.port,
+                        use_ssl:      uri.scheme == 'https',
+                        open_timeout: API_OPEN_TIMEOUT,
+                        read_timeout: API_READ_TIMEOUT) do |http|
+          response = http.request(Net::HTTP::Get.new(uri.request_uri))
+          if response.code.to_i == 200
+            payload = JSON.parse(response.body)
+            return Array(payload['skills'])
+          else
+            @errors << "API #{host}: HTTP #{response.code}"
+          end
+        end
+      rescue StandardError => e
+        @errors << "API #{host}: #{e.class}: #{e.message}"
+      end
+    end
+    nil
+  end
+
+  private def install_one(skill)
+    name         = skill['name'].to_s
+    download_url = skill['download_url'].to_s
+    @attempted  += 1
+
+    if name.empty? || download_url.empty?
+      @errors << "skill payload missing name or download_url: #{skill.inspect}"
+      return
+    end
+
+    result = ZipSkillInstaller.new(
+      download_url,
+      skill_name:     name,
+      target_dir:     @target_dir,
+      skip_if_exists: true
+    ).perform
+    @installed        += result[:installed].size
+    @skipped_existing += result[:skipped].size
+    @errors.concat(result[:errors]) if result[:errors].any?
+  rescue StandardError => e
+    @errors << "#{name}: #{e.class}: #{e.message}"
+  end
+
+  private def emit_summary
+    unless @errors.empty?
+      warn '[install_builtin_skills] non-fatal errors:'
+      @errors.each { |e| warn "  - #{e}" }
+    end
+    puts JSON.generate(
+      installed:        @installed,
+      attempted:        @attempted,
+      skipped_existing: @skipped_existing
+    )
+  end
+end
+
+BuiltinSkillsInstaller.new.run if __FILE__ == $0

data/lib/octo/default_skills/persist-memory/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: persist-memory
+description: Persist information to long-term memory at ~/.octo/memories/. Use when the user asks you to remember/note something, or when reviewing a finished conversation for facts worth keeping. Handles file naming, topic merging, frontmatter, and size limits.
+fork_agent: true
+user-invocable: false
+auto_summarize: true
+forbidden_tools:
+  - web_search
+  - web_fetch
+  - browser
+---
+
+# Persist Memory Subagent
+
+You are a **Memory Persistence Subagent** — a pure executor. The caller has already decided that something must be written. Your job is to write it correctly: pick the right file, merge with existing content, respect the size limit.
+
+You do NOT decide whether to write. If the task description tells you to persist X, you persist X.
+
+## Existing Memory Files
+
+The following memory files are pre-loaded for you — **do NOT re-scan the directory** with `terminal` or `file_reader`.
+
+<%= memories_meta %>
+
+Each file uses YAML frontmatter:
+
+```
+---
+topic: <topic name>
+description: <one-line description>
+---
+<content in concise Markdown>
+```
+
+## Workflow
+
+For each item to persist:
+
+### Step 1: Pick a target file
+
+Scan the list above:
+
+- **Matching topic exists** → read it with `file_reader(path: "~/.octo/memories/<filename>")`, integrate the new info, drop stale parts, then `write` the updated version back.
+- **No match** → create a new file at `~/.octo/memories/<topic-slug>.md`.
+  - Slug: lowercase, hyphen-separated, descriptive (e.g. `deployment-target.md`, `code-style-preferences.md`).
+
+### Step 2: Write the file
+
+Use the `write` tool. Always include the YAML frontmatter shown above.
+
+## Hard constraints (CRITICAL)
+
+- Each file MUST stay under **4000 characters of content** (after the frontmatter).
+- If merging would exceed this limit, remove the least important information — do NOT split into multiple files for the same topic.
+- Write concise, factual Markdown — no fluff, no redundant headings.
+- One topic per file. Don't bundle unrelated facts together.
+- Do NOT use `terminal` or `file_reader` to list the memories directory — the list above is authoritative.
+
+When done, briefly state what was written (e.g. "Updated deployment-target.md") or `No memory updates needed.` if the task description didn't actually require any writes.

data/lib/octo/default_skills/personal-website/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: personal-website
+description: |
+  Generate a beautiful personal homepage (linktree-style) and publish it online for the user.
+  Reads user info from ~/.octo/agents/USER.md and AI info from ~/.octo/agents/SOUL.md.
+  Returns a public URL the user can share.
+  Trigger on: "profile card", "homepage", "personal page", "generate my card", "make my card",
+  "publish my card", "生成名片", "做名片", "我的名片", "个人主页", "发布主页",
+  "delete my card", "删除名片", "删除主页".
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+---
+
+# Profile Homepage Skill
+
+Generate a beautiful personal homepage and publish it at a public URL.
+
+---
+
+## Step 1 — Read user info
+
+Read `~/.octo/agents/USER.md` and `~/.octo/agents/SOUL.md`.
+
+Extract everything you can find:
+- `name` — display name (fallback: "Friend")
+- `occupation` — job title or role (fallback: "")
+- `bio` — short personal description (fallback: "")
+- `links` — **all** social/contact links found, preserve their labels. Common ones to look for:
+  GitHub, Twitter/X, LinkedIn, Website, Blog, Email, Instagram, YouTube, Telegram, WeChat, etc.
+  Each link: `{ label, url, type }` where type helps pick an icon emoji.
+- `ai_name` — AI assistant name from SOUL.md (fallback: "Octo")
+- `personality` — professional / friendly / creative / concise (from SOUL.md, fallback: "friendly")
+
+---
+
+## Step 2 — Handle delete request
+
+If the user asked to **delete** their homepage:
+1. Find the skill's own directory (same folder as this SKILL.md). Call it `SKILL_DIR`.
+2. Run:
+   ```bash
+   ruby SKILL_DIR/publish.rb delete
+   ```
+   The script reads the slug automatically from `~/octo_workspace/personal_website/token.json`.
+3. Tell the user their homepage has been removed. Stop here.
+
+---
+
+## Step 3 — Design & generate the HTML
+
+Write a **complete, self-contained** HTML file to `/tmp/profile-card.html`.
+
+### You have full creative freedom on:
+- Layout, typography, spacing, color palette
+- Background (solid / gradient / subtle pattern / animated)
+- Link button style (pill / card / underline / ghost / anything)
+- Avatar treatment (large initial letter with color, emoji, geometric shape — no real image needed)
+- Animations (subtle hover effects, entrance fade, etc.)
+- Overall vibe — make it feel like a real personal brand page, not a template
+
+### Hard constraints (must follow):
+- **Single HTML file, zero external resources** — no CDN, no Google Fonts URLs, no `<img src="http...">`.
+  Use system fonts: `'Helvetica Neue', Arial, 'PingFang SC', 'Hiragino Sans GB', sans-serif`
+- **Mobile-first, responsive** — `<meta name="viewport">` required, works on phone screens
+- **Valid HTML5**
+- **All links open in `_blank`** with `rel="noopener"`
+- **Badge** somewhere subtle: `made by {ai_name} personal assistant` — small, not intrusive
+- Page `<title>`: `{name}'s Homepage` or similar
+
+### Link icons (use emoji prefix in button text):
+| Type     | Emoji |
+|----------|-------|
+| github   | 🐙 |
+| twitter/x | 🐦 |
+| linkedin | 💼 |
+| website/blog | 🌐 |
+| email    | 📧 |
+| instagram | 📸 |
+| youtube  | ▶️ |
+| telegram | ✈️ |
+| default  | 🔗 |
+
+---
+
+## Step 4 — Publish
+
+Find the skill directory (same folder as this SKILL.md). Call it `SKILL_DIR`.
+
+Run:
+```bash
+ruby SKILL_DIR/publish.rb publish \
+  --name "NAME" \
+  --html-file /tmp/profile-card.html
+```
+
+- First publish → creates new page, saves token to `~/octo_workspace/personal_website/token.json`
+- Subsequent runs → updates existing page at the same URL
+
+Capture stdout. Extract the URL from the output line starting with `✅`.
+
+---
+
+## Step 5 — Done
+
+Tell the user their homepage is live. Share the URL. Be warm and natural.
+
+Example (adapt tone to personality):
+> Your homepage is live 🌟
+> → http://localhost:3000/~ya-fei
+>
+> It's got all your links in one place. Share it anywhere.