prompt_objects 0.5.0 → 0.7.0

data/lib/prompt_objects/server.rb

@@ -27,9 +27,17 @@ module PromptObjects
       puts ""
       puts "Prompt Objects:"
       runtime.registry.prompt_objects.each do |po|
-        puts "  - #{po.name}: #{po.description}"
+        auto = po.autonomous? ? " (autonomous: #{po.autonomous_config['interval']}s)" : ""
+        puts "  - #{po.name}: #{po.description}#{auto}"
       end
       puts ""
+      if runtime.services.any?
+        puts "Services:"
+        runtime.services.each do |s|
+          puts "  - #{s.name}: #{s.description || '(no description)'}"
+        end
+        puts ""
+      end
       puts "Press Ctrl+C to stop"
       puts ""
 
@@ -59,6 +67,9 @@ module PromptObjects
         puts "Broadcast: PO modified (programmatic) - #{po.name}"
       }
 
+      # Register broadcast callback for services to push WebSocket messages
+      runtime.on_broadcast = ->(message) { app.broadcast(message) }
+
       # Start file watcher for live updates (manual file edits)
       file_watcher = nil
       if env_path
@@ -69,6 +80,12 @@ module PromptObjects
         file_watcher.start
       end
 
+      # Start environment services (calls service.start, no scheduling yet)
+      runtime.start_services if runtime.services.any?
+
+      # Start environment connectors (Discord/Slack/webhook bridges)
+      runtime.start_connectors if runtime.connectors.any?
+
       # Write .server file for CLI discovery
       server_file = write_server_file(env_path, host: host, port: port) if env_path
 
@@ -80,15 +97,167 @@ module PromptObjects
           endpoint
         )
 
+        # Schedule service tick loops as Async tasks.
+        # These cooperate with Falcon's event loop instead of fighting it.
+        schedule_service_ticks(task, runtime)
+
+        # Schedule autonomous PO execution as Async tasks.
+        schedule_autonomous_pos(task, runtime, app)
+
         task.async do
           server.run
         end
       ensure
+        runtime.stop_connectors if runtime.connectors.any?
+        runtime.stop_services if runtime.services.any?
+        runtime.shutdown_execution(wait: false)
         file_watcher&.stop
+        app.close
         remove_server_file(server_file) if server_file
       end
     end
 
+    # Schedule Async tick tasks for services that have an interval.
+    # Runs inside the Async event loop so ticks cooperate with Falcon.
+    # @param task [Async::Task] The parent Async task
+    # @param runtime [Runtime] The environment runtime
+    def self.schedule_service_ticks(task, runtime)
+      runtime.services.each do |service|
+        next unless service.interval
+
+        task.async do |subtask|
+          puts "Service tick loop started: #{service.name} (every #{service.interval}s)"
+          loop do
+            subtask.sleep service.interval
+            service.tick
+          rescue => e
+            warn "Service #{service.name} tick error: #{e.class}: #{e.message}"
+          end
+        end
+      end
+    end
+
+    # Schedule Async tasks for autonomous POs that think on their own interval.
+    # Uses runtime.inject_message — the same code path as human messages,
+    # service events, and webhooks.
+    # @param task [Async::Task] The parent Async task
+    # @param runtime [Runtime] The environment runtime
+    # @param app [App] The server app (unused — broadcasting goes through runtime)
+    def self.schedule_autonomous_pos(task, runtime, app)
+      runtime.registry.prompt_objects.each do |po|
+        next unless po.autonomous?
+
+        auto_config = po.autonomous_config
+        next unless auto_config["start_on_boot"]
+
+        po_name = po.name
+
+        task.async do |subtask|
+          puts "Autonomous PO scheduled: #{po_name} (every #{auto_config['interval']}s, " \
+               "initial delay #{auto_config['initial_delay']}s)"
+
+          waiting_state = nil
+          loop do
+            current = current_autonomous_config(runtime, po_name)
+            break unless current && current["wait_for_human"] && !runtime.human_message_received?(po_name)
+
+            current_waiting_state = [current["interval"], current["initial_delay"]]
+            if current_waiting_state != waiting_state
+              runtime.update_autonomous_schedule(
+                po_name,
+                status: "waiting_for_human",
+                interval: current["interval"],
+                initial_delay: current["initial_delay"],
+                wait_for_human: true,
+                next_run_at: nil
+              )
+              waiting_state = current_waiting_state
+            end
+            subtask.sleep 0.1
+          end
+
+          next unless wait_for_live_autonomous_delay(
+            subtask, runtime, po_name, duration_key: "initial_delay"
+          )
+
+          loop do
+            current = current_autonomous_config(runtime, po_name)
+            break unless current
+
+            begin
+              runtime.update_autonomous_schedule(
+                po_name,
+                status: "running",
+                next_run_at: nil
+              )
+              # Autonomous work uses its own coalesced, summary-retention thread.
+              execution = lambda do
+                runtime.inject_message(
+                  target_po: po_name,
+                  content: current["message"].strip,
+                  from_source: "timer:#{po_name}"
+                )
+              end
+              if app.respond_to?(:blocking_executor)
+                app.blocking_executor.call(&execution)
+              else
+                execution.call
+              end
+            rescue => e
+              warn "Autonomous PO #{po_name} error: #{e.class}: #{e.message}"
+            end
+
+            break unless wait_for_live_autonomous_delay(
+              subtask, runtime, po_name, duration_key: "interval"
+            )
+          end
+        end
+      end
+    end
+
+    # Sleep until the PO's current autonomous deadline while re-reading its
+    # frontmatter. In-app and external source edits can therefore change the
+    # message used by the next tick and move an interval deadline without a
+    # server restart.
+    def self.wait_for_live_autonomous_delay(subtask, runtime, po_name, duration_key:)
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      published_deadline = nil
+
+      loop do
+        config = current_autonomous_config(runtime, po_name)
+        return false unless config
+
+        duration = [config[duration_key].to_f, 0].max
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+        remaining = duration - elapsed
+        return true if remaining <= 0
+
+        deadline = Time.now.utc + remaining
+        deadline_key = [duration, config["interval"], config["initial_delay"], config["wait_for_human"]]
+        if deadline_key != published_deadline
+          runtime.update_autonomous_schedule(
+            po_name,
+            status: "scheduled",
+            interval: config["interval"],
+            initial_delay: config["initial_delay"],
+            wait_for_human: config["wait_for_human"],
+            next_run_at: deadline.iso8601(6)
+          )
+          published_deadline = deadline_key
+        end
+
+        subtask.sleep([remaining, 0.1].min)
+      end
+    end
+
+    def self.current_autonomous_config(runtime, po_name)
+      po = runtime.registry.get(po_name)
+      return nil unless po.is_a?(PromptObject) && po.autonomous?
+
+      config = po.autonomous_config
+      config if config["start_on_boot"]
+    end
+
     # Write a .server file so CLI clients can discover the running server.
     # @param env_path [String] Path to the environment directory
     # @param host [String] Server host

data/lib/prompt_objects/service.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  # Base class for environment background services.
+  # Services run alongside the server and can publish to the message bus,
+  # write to env_data, and perform periodic background work.
+  #
+  # Subclasses live in an environment's services/ directory and are loaded
+  # automatically when the server starts.
+  #
+  # Example:
+  #   module PromptObjects
+  #     module Services
+  #       class MyHeartbeat < PromptObjects::Service
+  #         def description = "Polls external API every 10s"
+  #         def interval = 10
+  #         def tick
+  #           @runtime.bus.publish(from: "service:#{name}", to: "broadcast", message: "heartbeat")
+  #         end
+  #       end
+  #     end
+  #   end
+  # Namespace for custom environment services.
+  module Services; end
+
+  class Service
+    attr_reader :name, :description
+
+    def initialize(runtime:)
+      @runtime = runtime
+      @name = self.class.name.split("::").last
+                   .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                   .downcase
+      @description = nil
+    end
+
+    # Called when the server starts. Override to initialize resources.
+    def start; end
+
+    # Called when the server stops. Override to clean up resources.
+    def stop; end
+
+    # Seconds between ticks. Return nil to disable auto-tick.
+    def interval; nil; end
+
+    # Called every `interval` seconds. Override to perform periodic work.
+    def tick; end
+
+    # --- Shared environment data ---
+    #
+    # Services read and write the same env_data store as POs and autonomous
+    # ticks, scoped to the environment's active session. This replaces the old
+    # "__services__" sentinel thread id — heartbeat-style services no longer
+    # need to invent a scope, and what they store is visible to POs (and the
+    # live env data pane in the UI).
+
+    # Store a value in shared env_data, scoped to the active environment session.
+    # Creates the environment session on first write if one doesn't exist yet.
+    # @param key [String] Data key
+    # @param value [Object] JSON-serializable value
+    # @param short_description [String, nil] Summary for discoverability
+    # @return [Boolean] True if stored
+    def set_env_data(key, value, short_description: nil)
+      scope = env_data_scope(create: true)
+      return false unless scope
+
+      @runtime.session_store.store_env_data(
+        root_thread_id: scope,
+        key: key,
+        short_description: short_description || key.to_s,
+        value: value,
+        stored_by: "service:#{name}"
+      )
+      @runtime.notify_env_data_changed(
+        action: "set", root_thread_id: scope, key: key, stored_by: "service:#{name}"
+      )
+      true
+    end
+
+    # Read a value from shared env_data.
+    # @param key [String] Data key
+    # @return [Object, nil] The stored value, or nil if absent
+    def get_env_data(key)
+      scope = env_data_scope
+      return nil unless scope
+
+      entry = @runtime.session_store.get_env_data(root_thread_id: scope, key: key)
+      entry && entry[:value]
+    end
+
+    # List env_data keys and descriptions in the active environment session.
+    # @return [Array<Hash>] Entries with :key and :short_description
+    def list_env_data
+      scope = env_data_scope
+      return [] unless scope
+
+      @runtime.session_store.list_env_data(root_thread_id: scope)
+    end
+
+    # Delete an env_data entry.
+    # @param key [String] Data key
+    # @return [Boolean] True if a row was deleted
+    def delete_env_data(key)
+      scope = env_data_scope
+      return false unless scope
+
+      deleted = @runtime.session_store.delete_env_data(root_thread_id: scope, key: key)
+      if deleted
+        @runtime.notify_env_data_changed(
+          action: "delete", root_thread_id: scope, key: key, stored_by: "service:#{name}"
+        )
+      end
+      deleted
+    end
+
+    private
+
+    # Resolve the env_data scope (the active environment session). Pass
+    # create: true to establish the session on first write.
+    # @return [String, nil]
+    def env_data_scope(create: false)
+      return nil unless @runtime&.session_store
+
+      @runtime.active_session(initiated_by: "service:#{name}") if create
+      @runtime.env_data_scope
+    end
+  end
+end