Files
passepartout/skills/org-skill-gateway-manager.org
Amr Gharbeia fc0c069d65 tests: Add FiveAM tests for v0.2.0 completion
Self-edit: 5 new tests (apply success/not-found/file-not-found, parse-location x2)
Config-manager: 4 new tests (get-oc-config-dir, save-providers, configure-provider)
Gateway-manager: 2 new tests (multiple-platforms, registration)

Tier 1 Chaos: Verified org files pass structural balance
Note: Some tests have issues - config tests use functions not exported, one self-edit test has search function issue. Pre-existing test failures in LITERATE-PROGRAMMING (2) and DIAGNOSTICS (1).
2026-04-28 15:19:49 -04:00

6.0 KiB

Skill: Gateway Manager (org-skill-gateway-manager.org)

Overview

The Gateway Manager skill provides the OpenCortex Agent with the capability to manage its own external communication channels (Gateways).

Phase A: Demand (Thinking)

Architectural Invariant: Self-Linking

In a traditional AI wrapper, the user manually edits a config file to add a bot token. In OpenCortex, the Agent should be able to say: "I have verified the Telegram token and successfully linked our connection."

Phase B: Protocol (Success Criteria)

Test Suite Context

(defpackage :opencortex-gateway-manager-tests
  (:use :cl :fiveam :opencortex)
  (:export #:gateway-suite))
(in-package :opencortex-gateway-manager-tests)
(def-suite gateway-suite :description "Verification of the Gateway Manager skill")
(in-suite gateway-suite)

Logic Tests

(test test-gateway-registration
  "Verify that the skill can register a new gateway metadata block."
  (let ((opencortex::*gateways* nil))
    (opencortex:skill-gateway-register :telegram '(:status :unverified))
    (is (getf (getf opencortex::*gateways* :telegram) :status))))

(test test-gateway-multiple-platforms
  "Verify that multiple gateways can be registered simultaneously."
  (let ((opencortex::*gateways* nil))
    (opencortex:skill-gateway-register :telegram '(:status :verified :token "abc123"))
    (opencortex:skill-gateway-register :signal '(:status :unverified))
    (is (eq (getf (getf opencortex::*gateways* :telegram) :status) :verified))
    (is (eq (getf (getf opencortex::*gateways* :signal) :status) :unverified))))

Phase C: Implementation (Build)

Package Context

(in-package :opencortex)

Capability Definition

(defparameter *skill-gateway-manager*
  '(:name "gateway-manager"
    :description "Manages connections to external chat platforms."
    :capabilities (:link-gateway :list-gateways)
    :type :deterministic)
  "Skill metadata for the Gateway Manager.")

Registry Persistence

(defvar *gateways* nil "The internal registry of configured gateways.")

Persistence Stubs

(defun save-gateways ()
  "Persist gateway metadata to XDG Config directory."
  (let ((path (merge-pathnames "gateways.lisp" (get-oc-config-dir))))
    (ensure-directories-exist path)
    (with-open-file (s path :direction :output :if-exists :supersede)
      (format s ";;; OpenCortex Gateway Registry~%~s~%" *gateways*))))

Registration Logic

(defun skill-gateway-register (platform metadata)
  "Internal function to update the gateway registry."
  (setf (getf *gateways* platform) metadata))

Telegram Verification

(defun skill-gateway-verify-telegram (token)
  "Verifies a Telegram bot token via the getMe API."
  (let ((url (format nil "https://api.telegram.org/bot~a/getMe" token)))
    (handler-case
        (let* ((response (dex:get url))
               (data (cl-json:decode-json-from-string response)))
          (if (cdr (assoc :ok data))
              (let ((result (cdr (assoc :result data))))
                (list :status :verified :username (cdr (assoc :username result))))
              (list :status :failed :error "Invalid Token")))
      (error (c) (list :status :failed :error (format nil "~a" c))))))

Linkage Command

(defun skill-gateway-link (platform token)
  "Primary capability to link a new platform. Returns status plist."
  (harness-log "GATEWAY: Attempting to link ~a..." platform)
  (let ((verification (cond 
                        ((eq platform :telegram) (skill-gateway-verify-telegram token))
                        (t (list :status :verified :info "Platform verification pending implementation")))))
    (if (eq (getf verification :status) :verified)
        (progn
          (save-secret platform :token token)
          (skill-gateway-register platform verification)
          (save-gateways)
          (list :status :success :platform platform :info verification))
        (list :status :error :reason (getf verification :error)))))

CLI Main Wrapper

(defun gateway-manager-main (platform token)
  "Main entry point for CLI-driven linkage."
  (if (and platform token)
      (let ((result (skill-gateway-link (intern (string-upcase platform) :keyword) token)))
        (format t "RESULT: ~s~%" result)
        (uiop:quit 0))
      (progn
        (format t "Usage: opencortex link <PLATFORM> <TOKEN>~%")
        (uiop:quit 1))))