feat: update plugin service authoring templates

crates/plugin-pdk/src/lib.rs

@@ -468,15 +468,48 @@ mod tests {
         assert!(error.message().len() <= MAX_ERROR_MESSAGE_BYTES + "…".len());
     }
 
+    #[test]
+    fn service_output_helper_builds_runtime_command_envelope() {
+        let event = PluginIngressEvent {
+            kind: "websocket_text".to_string(),
+            source: "websocket:wss://example.test/socket".to_string(),
+            ingress_name: "example_ws".to_string(),
+            payload: json!({"text":"ping"}),
+            created_at: "2026-06-25T00:00:00Z".to_string(),
+            attempt: 1,
+            correlation_id: "event-1".to_string(),
+        };
+
+        assert_eq!(event.websocket_text(), Some("ping"));
+        let output =
+            ServiceOutput::websocket_send(&event, "reply-1", "wss://example.test/socket", "pong")
+                .unwrap();
+        let value = serde_json::to_value(output).unwrap();
+
+        assert_eq!(value["accepted"], true);
+        assert_eq!(value["output_commands"][0]["source_event_id"], "event-1");
+        assert_eq!(value["output_commands"][0]["command_id"], "reply-1");
+        assert_eq!(value["output_commands"][0]["kind"], "websocket_send");
+        assert_eq!(value["output_commands"][0]["payload"]["text"], "pong");
+        assert_eq!(
+            value["output_commands"][0]["requested_at"],
+            "2026-06-25T00:00:00Z"
+        );
+    }
+
     #[test]
     fn wit_constants_match_current_world() {
         assert!(TOOL_WIT.contains("package yoi:plugin@1.0.0"));
         assert!(TOOL_WIT.contains("world tool"));
         assert!(TOOL_WIT.contains("export call"));
         assert_eq!(TOOL_WORLD, "yoi:plugin/tool@1.0.0");
-        assert!(HOST_WIT.contains("interface https"));
+        assert!(HOST_WIT.contains("interface request"));
+        assert!(HOST_WIT.contains("interface websocket"));
         assert!(HOST_WIT.contains("interface fs"));
         assert!(HOST_WIT.contains("%list: func"));
+        assert!(INSTANCE_WIT.contains("world instance"));
+        assert!(INSTANCE_WIT.contains("export handle-ingress"));
+        assert!(INSTANCE_WIT.contains("websocket_send"));
     }
 }
 
@@ -488,12 +521,48 @@ pub const PLUGIN_INSTANCE_WORLD: &str = "yoi:plugin/instance@1.0.0";
 pub const INSTANCE_WIT: &str =
     include_str!("../../../resources/plugin/wit/yoi-plugin-instance-v1.wit");
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct PluginIngressEvent {
     pub kind: String,
     pub source: String,
     #[serde(default)]
+    pub ingress_name: String,
+    #[serde(default)]
     pub payload: Value,
+    #[serde(default)]
+    pub created_at: String,
+    #[serde(default = "default_attempt")]
+    pub attempt: u32,
+    #[serde(default)]
+    pub correlation_id: String,
+}
+
+impl PluginIngressEvent {
+    /// Return the text payload carried by a host-owned WebSocket ingress event.
+    pub fn websocket_text(&self) -> Option<&str> {
+        self.payload.get("text").and_then(Value::as_str)
+    }
+
+    /// Build a `websocket_send` output command that replies through the
+    /// host-owned Service WebSocket driver. The host still validates the target
+    /// URL and matching grants before sending.
+    pub fn websocket_send(
+        &self,
+        command_id: impl Into<String>,
+        url: impl Into<String>,
+        text: impl Into<String>,
+    ) -> Result<ServiceOutputCommand> {
+        ServiceOutputCommand::new(
+            self,
+            command_id,
+            ServiceOutputCommandKind::WebSocketSend,
+            serde_json::json!({ "url": url.into(), "text": text.into() }),
+        )
+    }
+}
+
+fn default_attempt() -> u32 {
+    1
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -519,12 +588,118 @@ impl PluginStatus {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ServiceOutputCommandKind {
+    DiagnosticStatusUpdate,
+    HostRequestDispatch,
+    #[serde(rename = "websocket_send")]
+    WebSocketSend,
+}
+
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ServiceOutputCommand {
+    pub correlation_id: String,
+    pub source_event_id: String,
+    pub command_id: String,
+    pub kind: ServiceOutputCommandKind,
+    pub payload: Value,
+    pub requested_at: String,
+}
+
+impl ServiceOutputCommand {
+    pub fn new(
+        event: &PluginIngressEvent,
+        command_id: impl Into<String>,
+        kind: ServiceOutputCommandKind,
+        payload: impl Serialize,
+    ) -> Result<Self> {
+        let command_id = sanitize_command_id(command_id.into());
+        if command_id.is_empty() {
+            return Err(ToolError::invalid_output(
+                "service output command_id must not be empty",
+            ));
+        }
+        let source_event_id = event.correlation_id.clone();
+        if source_event_id.is_empty() {
+            return Err(ToolError::invalid_output(
+                "service output command requires ingress event correlation_id",
+            ));
+        }
+        let requested_at = if event.created_at.is_empty() {
+            "1970-01-01T00:00:00Z".to_string()
+        } else {
+            event.created_at.clone()
+        };
+        Ok(Self {
+            correlation_id: sanitize_command_id(format!("{source_event_id}:{command_id}")),
+            source_event_id,
+            command_id,
+            kind,
+            payload: serde_json::to_value(payload).map_err(ToolError::serialization)?,
+            requested_at,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ServiceOutput {
+    #[serde(default)]
+    pub accepted: bool,
+    #[serde(default, skip_serializing_if = "Value::is_null")]
+    pub data: Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub output_commands: Vec<ServiceOutputCommand>,
+}
+
+impl ServiceOutput {
+    pub fn accepted(data: impl Serialize) -> Result<Self> {
+        Ok(Self {
+            accepted: true,
+            data: serde_json::to_value(data).map_err(ToolError::serialization)?,
+            output_commands: Vec::new(),
+        })
+    }
+
+    pub fn empty() -> Self {
+        Self {
+            accepted: true,
+            data: Value::Null,
+            output_commands: Vec::new(),
+        }
+    }
+
+    pub fn with_command(mut self, command: ServiceOutputCommand) -> Self {
+        self.output_commands.push(command);
+        self
+    }
+
+    pub fn websocket_send(
+        event: &PluginIngressEvent,
+        command_id: impl Into<String>,
+        url: impl Into<String>,
+        text: impl Into<String>,
+    ) -> Result<Self> {
+        Ok(Self::empty().with_command(event.websocket_send(command_id, url, text)?))
+    }
+}
+
+fn sanitize_command_id(value: String) -> String {
+    bounded_text(
+        value
+            .chars()
+            .map(|ch| if ch.is_control() { '-' } else { ch })
+            .collect(),
+        128,
+    )
+}
+
 /// Rust-facing instance Plugin contract. Hosts call `start` once, then route
 /// Tool/Ingress surfaces through the same mutable instance.
 pub trait Plugin: Sized + 'static {
     fn start(config: Value) -> Result<Self>;
     fn handle_tool(&mut self, name: &str, input: Value) -> Result<ToolOutput>;
-    fn handle_ingress(&mut self, name: &str, event: PluginIngressEvent) -> Result<Value>;
+    fn handle_ingress(&mut self, name: &str, event: PluginIngressEvent) -> Result<ServiceOutput>;
     fn status(&self) -> Result<PluginStatus> {
         Ok(PluginStatus::ready(Value::Null))
     }

crates/plugin-pdk/tests/template.rs

@@ -12,6 +12,14 @@ const TEMPLATE_PLUGIN: &str =
     include_str!("../../../resources/plugin/templates/rust-component-tool/plugin.toml");
 const TEMPLATE_README: &str =
     include_str!("../../../resources/plugin/templates/rust-component-tool/README.md");
+const SERVICE_TEMPLATE_CARGO: &str =
+    include_str!("../../../resources/plugin/templates/rust-component-instance/Cargo.toml");
+const SERVICE_TEMPLATE_LIB: &str =
+    include_str!("../../../resources/plugin/templates/rust-component-instance/src/lib.rs");
+const SERVICE_TEMPLATE_PLUGIN: &str =
+    include_str!("../../../resources/plugin/templates/rust-component-instance/plugin.toml");
+const SERVICE_TEMPLATE_README: &str =
+    include_str!("../../../resources/plugin/templates/rust-component-instance/README.md");
 const SAMPLE_LIB: &str = include_str!("../../../docs/examples/plugin-component-tool/lib.rs");
 const PDK_CARGO: &str = include_str!("../Cargo.toml");
 
@@ -25,7 +33,7 @@ fn rust_component_tool_template_has_expected_files() {
         cargo["dependencies"]["yoi-plugin-pdk"]["path"].as_str(),
         Some("../../../../crates/plugin-pdk")
     );
-    assert!(TEMPLATE_CARGO.contains("rev = \"<pinned-yoi-revision>\""));
+    assert!(TEMPLATE_CARGO.contains("rev = \"<pinned-yoi-commit-sha>\""));
 
     let plugin: Value = toml::from_str(TEMPLATE_PLUGIN).expect("template plugin.toml parses");
     assert_eq!(plugin["schema_version"].as_integer(), Some(1));
@@ -45,6 +53,56 @@ fn rust_component_tool_template_has_expected_files() {
     assert!(TEMPLATE_README.contains("Component Model Tool Plugin"));
 }
 
+#[test]
+fn rust_component_service_template_has_event_output_pattern() {
+    let cargo: Value = toml::from_str(SERVICE_TEMPLATE_CARGO).expect("service Cargo.toml parses");
+    assert_eq!(cargo["package"]["edition"].as_str(), Some("2024"));
+    assert_eq!(cargo["lib"]["crate-type"][0].as_str(), Some("cdylib"));
+    assert_eq!(
+        cargo["dependencies"]["yoi-plugin-pdk"]["path"].as_str(),
+        Some("../../../../crates/plugin-pdk")
+    );
+    assert!(SERVICE_TEMPLATE_CARGO.contains("rev = \"<pinned-yoi-commit-sha>\""));
+
+    let plugin: Value =
+        toml::from_str(SERVICE_TEMPLATE_PLUGIN).expect("service plugin.toml parses");
+    assert_eq!(plugin["schema_version"].as_integer(), Some(1));
+    assert_eq!(plugin["runtime"]["kind"].as_str(), Some("wasm-component"));
+    assert_eq!(
+        plugin["runtime"]["world"].as_str(),
+        Some("yoi:plugin/instance@1.0.0")
+    );
+    assert_eq!(
+        plugin["services"].as_array().expect("services array").len(),
+        1
+    );
+    let ingress = &plugin["ingresses"].as_array().expect("ingresses array")[0];
+    assert!(
+        ingress["event_kinds"]
+            .as_array()
+            .expect("event kinds")
+            .iter()
+            .any(|kind| kind.as_str() == Some("websocket_text"))
+    );
+    assert!(
+        ingress["sources"]
+            .as_array()
+            .expect("sources")
+            .iter()
+            .any(|source| source
+                .as_str()
+                .unwrap_or_default()
+                .starts_with("websocket:wss://"))
+    );
+
+    assert!(SERVICE_TEMPLATE_LIB.contains("world: \"instance\""));
+    assert!(SERVICE_TEMPLATE_LIB.contains("PluginIngressEvent"));
+    assert!(SERVICE_TEMPLATE_LIB.contains("ServiceOutput::websocket_send"));
+    assert!(!SERVICE_TEMPLATE_LIB.contains("recv(timeout"));
+    assert!(SERVICE_TEMPLATE_README.contains("output command"));
+    assert!(!SERVICE_TEMPLATE_PLUGIN.contains("kind = \"wasm\""));
+}
+
 #[test]
 fn documented_sample_uses_pdk_component_path() {
     assert!(SAMPLE_LIB.contains("use yoi_plugin_pdk::wit_bindgen"));
@@ -57,8 +115,17 @@ fn documented_sample_uses_pdk_component_path() {
 
 #[test]
 fn embedded_template_cargo_checks_for_wasm_target() {
+    cargo_check_template("rust-component-tool");
+}
+
+#[test]
+fn embedded_service_template_cargo_checks_for_wasm_target() {
+    cargo_check_template("rust-component-instance");
+}
+
+fn cargo_check_template(template: &str) {
     let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-    let template_dir = crate_dir.join("../../resources/plugin/templates/rust-component-tool");
+    let template_dir = crate_dir.join(format!("../../resources/plugin/templates/{template}"));
     let manifest_path = template_dir.join("Cargo.toml");
     let lock_path = template_dir.join("Cargo.lock");
     let _ = fs::remove_file(&lock_path);

crates/yoi/src/main.rs

@@ -727,7 +727,7 @@ fn parse_plugin_pack_args(
 }
 
 fn plugin_usage() -> &'static str {
-    "usage: yoi plugin new rust-component-tool <path-or-name> [--json]\n       yoi plugin check <path-or-package> [--json]\n       yoi plugin pack <path> [--output <file>] [--json]\n       yoi plugin list [--workspace PATH] [--profile REF] [--json]\n       yoi plugin show <ref> [--workspace PATH] [--profile REF] [--json]"
+    "usage: yoi plugin new <rust-component-tool|rust-component-service> <path-or-name> [--json]\n       yoi plugin check <path-or-package> [--json]\n       yoi plugin pack <path> [--output <file>] [--json]\n       yoi plugin list [--workspace PATH] [--profile REF] [--json]\n       yoi plugin show <ref> [--workspace PATH] [--profile REF] [--json]"
 }
 
 fn parse_mcp_args(args: &[String]) -> Result<mcp_cli::McpCliCommand, ParseError> {
@@ -901,7 +901,7 @@ fn parse_session_id(value: &str) -> Result<SegmentId, ParseError> {
 
 fn print_help() {
     println!(
-        "yoi\n\nUsage:\n  yoi [OPTIONS]\n  yoi resume [--workspace <PATH>] [--all]\n  yoi panel [--workspace <PATH>]\n  yoi keys\n  yoi setup-model\n  yoi pod [POD_OPTIONS]\n  yoi pod delete <NAME> [--force] [--dry-run]\n  yoi pod prune --older-than <DURATION> [--force] [--dry-run]\n  yoi objective <COMMAND> [OPTIONS]\n  yoi session analyze <SESSION_JSONL_PATH> --json\n  yoi session prune --unreferenced [--older-than <DURATION>] [--force] [--dry-run]\n  yoi ticket <COMMAND> [OPTIONS]\n  yoi workspace serve [OPTIONS]\n  yoi plugin new rust-component-tool <PATH> [--json]\n  yoi plugin check <PATH_OR_PACKAGE> [--json]\n  yoi plugin pack <PATH> [--output <FILE>] [--json]\n  yoi plugin list [--workspace <PATH>] [--profile <REF>] [--json]\n  yoi plugin show <REF> [--workspace <PATH>] [--profile <REF>] [--json]\n  yoi mcp list [--workspace <PATH>] [--profile <REF>] [--json]\n  yoi mcp show <SERVER> [--workspace <PATH>] [--profile <REF>] [--json]\n  yoi mcp tools|resources|prompts [SERVER] [--workspace <PATH>] [--profile <REF>] [--json]\n  yoi memory lint [OPTIONS]\n\nSurfaces:\n  Console   Single-Pod chat/client surface (default, --pod, yoi resume)\n  Dashboard Workspace cockpit/action surface (yoi panel)\n  TUI       Terminal UI implementation umbrella for Console and Dashboard\n\nOptions:\n      --workspace <PATH> Runtime workspace root for default Console/--pod (defaults to cwd)\n      --pod <NAME>       Open the Pod Console by name (attach/restore/create)\n      --socket <PATH>    Attach a Pod Console to a specific socket with --pod\n      --session <UUID>   Resume a specific session segment in the Pod Console\n      --profile <REF>    Select a reusable Profile recipe\n  -h, --help             Print help\n"
+        "yoi\n\nUsage:\n  yoi [OPTIONS]\n  yoi resume [--workspace <PATH>] [--all]\n  yoi panel [--workspace <PATH>]\n  yoi keys\n  yoi setup-model\n  yoi pod [POD_OPTIONS]\n  yoi pod delete <NAME> [--force] [--dry-run]\n  yoi pod prune --older-than <DURATION> [--force] [--dry-run]\n  yoi objective <COMMAND> [OPTIONS]\n  yoi session analyze <SESSION_JSONL_PATH> --json\n  yoi session prune --unreferenced [--older-than <DURATION>] [--force] [--dry-run]\n  yoi ticket <COMMAND> [OPTIONS]\n  yoi workspace serve [OPTIONS]\n  yoi plugin new <rust-component-tool|rust-component-service> <PATH> [--json]\n  yoi plugin check <PATH_OR_PACKAGE> [--json]\n  yoi plugin pack <PATH> [--output <FILE>] [--json]\n  yoi plugin list [--workspace <PATH>] [--profile <REF>] [--json]\n  yoi plugin show <REF> [--workspace <PATH>] [--profile <REF>] [--json]\n  yoi mcp list [--workspace <PATH>] [--profile <REF>] [--json]\n  yoi mcp show <SERVER> [--workspace <PATH>] [--profile <REF>] [--json]\n  yoi mcp tools|resources|prompts [SERVER] [--workspace <PATH>] [--profile <REF>] [--json]\n  yoi memory lint [OPTIONS]\n\nSurfaces:\n  Console   Single-Pod chat/client surface (default, --pod, yoi resume)\n  Dashboard Workspace cockpit/action surface (yoi panel)\n  TUI       Terminal UI implementation umbrella for Console and Dashboard\n\nOptions:\n      --workspace <PATH> Runtime workspace root for default Console/--pod (defaults to cwd)\n      --pod <NAME>       Open the Pod Console by name (attach/restore/create)\n      --socket <PATH>    Attach a Pod Console to a specific socket with --pod\n      --session <UUID>   Resume a specific session segment in the Pod Console\n      --profile <REF>    Select a reusable Profile recipe\n  -h, --help             Print help\n"
     );
 }
 

crates/yoi/src/plugin_cli.rs

@@ -9,10 +9,10 @@ use manifest::plugin::{
     MaterializedPluginPackage, PluginConfig, PluginDiagnostic, PluginDiagnosticKind,
     PluginDiagnosticPhase, PluginDiscoveryLimits, PluginDiscoveryOptions, PluginDiscoveryReport,
     PluginExactVersion, PluginGrantConfig, PluginPackageManifest, PluginPermission,
-    PluginResolution, PluginSourceKind, PluginSurface, RUST_COMPONENT_TOOL_TEMPLATE,
-    ResolvedPlugin, ResolvedPluginRecord, SourceQualifiedPluginId, discover_plugins,
-    read_plugin_directory, read_plugin_package_file, resolve_enabled_plugins,
-    write_plugin_package_file,
+    PluginResolution, PluginSourceKind, PluginSurface, PluginTemplateResource,
+    RUST_COMPONENT_INSTANCE_TEMPLATE, RUST_COMPONENT_TOOL_TEMPLATE, ResolvedPlugin,
+    ResolvedPluginRecord, SourceQualifiedPluginId, discover_plugins, read_plugin_directory,
+    read_plugin_package_file, resolve_enabled_plugins, write_plugin_package_file,
 };
 use manifest::{ProfileResolveOptions, ProfileResolver, ProfileSelector, paths};
 use pod::feature::plugin::{PluginStaticInspection, inspect_resolved_plugin_static};
@@ -85,27 +85,29 @@ pub(crate) fn run(command: PluginCliCommand) -> Result<()> {
 }
 
 fn render_new(template: &str, destination: &Path, args: &PluginCliArgs) -> Result<String> {
-    if template != "rust-component-tool" {
-        return Err(format!(
-            "unsupported plugin template `{template}` (supported: rust-component-tool)"
-        )
-        .into());
+    let (template_name, resources) = embedded_template_resources(template)?;
+    materialize_template(destination, resources)?;
+    let mut next_steps = vec![
+        "Review plugin.toml and generated Rust source.".to_string(),
+        "Replace the placeholder plugin.component.wasm with a real built component before enabling or execution.".to_string(),
+        "Run `yoi plugin check <path>` and then `yoi plugin pack <path>`.".to_string(),
+    ];
+    if template == "rust-component-service" {
+        next_steps.insert(
+            1,
+            "Implement Service ingress logic in handle_ingress and return ServiceOutput output_commands for host-owned WebSocket sends.".to_string(),
+        );
     }
-    materialize_template(destination)?;
     let report = NewReport {
         command: "new",
-        template: "rust-component-tool",
+        template: template_name,
         destination: destination.display().to_string(),
-        files: RUST_COMPONENT_TOOL_TEMPLATE
+        files: resources
             .iter()
             .map(|resource| resource.path.to_string())
             .collect(),
         safety: AuthoringSafetyReport::default(),
-        next_steps: vec![
-            "Review plugin.toml and generated Rust source.".to_string(),
-            "Replace the placeholder plugin.component.wasm with a real built component before enabling or execution.".to_string(),
-            "Run `yoi plugin check <path>` and then `yoi plugin pack <path>`.".to_string(),
-        ],
+        next_steps,
     };
     if args.json {
         return Ok(format!("{}\n", serde_json::to_string_pretty(&report)?));
@@ -113,7 +115,23 @@ fn render_new(template: &str, destination: &Path, args: &PluginCliArgs) -> Resul
     render_new_human(&report)
 }
 
-fn materialize_template(destination: &Path) -> Result<()> {
+fn embedded_template_resources(
+    template: &str,
+) -> Result<(&'static str, &'static [PluginTemplateResource])> {
+    match template {
+        "rust-component-tool" => Ok(("rust-component-tool", RUST_COMPONENT_TOOL_TEMPLATE)),
+        "rust-component-service" => Ok(("rust-component-service", RUST_COMPONENT_INSTANCE_TEMPLATE)),
+        _ => Err(format!(
+            "unsupported plugin template `{template}` (supported: rust-component-tool, rust-component-service)"
+        )
+        .into()),
+    }
+}
+
+fn materialize_template(
+    destination: &Path,
+    resources: &'static [PluginTemplateResource],
+) -> Result<()> {
     match fs::symlink_metadata(destination) {
         Ok(metadata) => {
             if metadata.file_type().is_symlink() {
@@ -144,7 +162,7 @@ fn materialize_template(destination: &Path) -> Result<()> {
         Err(error) => return Err(error.into()),
     }
 
-    for resource in RUST_COMPONENT_TOOL_TEMPLATE {
+    for resource in resources {
         let relative = safe_template_relative_path(resource.path)?;
         let path = destination.join(relative);
         if let Some(parent) = path.parent() {
@@ -2136,6 +2154,61 @@ mod tests {
         let human_check = render_check(&destination, &PluginCliArgs::default()).unwrap();
         assert!(human_check.contains("[partial]"));
         assert!(human_check.contains("not ready to enable"));
+
+        let service_destination = dir.path().join("my-service-plugin");
+        let service_json = render_new(
+            "rust-component-service",
+            &service_destination,
+            &PluginCliArgs {
+                json: true,
+                ..PluginCliArgs::default()
+            },
+        )
+        .unwrap();
+        let service_value: serde_json::Value = serde_json::from_str(&service_json).unwrap();
+        assert_eq!(service_value["template"], "rust-component-service");
+        assert!(
+            service_value["next_steps"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .any(|step| step
+                    .as_str()
+                    .unwrap_or_default()
+                    .contains("Service ingress"))
+        );
+        for resource in RUST_COMPONENT_INSTANCE_TEMPLATE {
+            assert!(
+                service_destination.join(resource.path).is_file(),
+                "missing service {}",
+                resource.path
+            );
+        }
+        let manifest = fs::read_to_string(service_destination.join("plugin.toml")).unwrap();
+        assert!(manifest.contains("kind = \"wasm-component\""));
+        assert!(manifest.contains("[[services]]"));
+        assert!(manifest.contains("[[ingresses]]"));
+        let source = fs::read_to_string(service_destination.join("src/lib.rs")).unwrap();
+        assert!(source.contains("ServiceOutput::websocket_send"));
+        assert!(!source.contains("recv(timeout"));
+        let service_check = render_check(&service_destination, &PluginCliArgs::default()).unwrap();
+        assert!(service_check.contains("plugin check:"));
+        assert!(service_check.contains("service"));
+        let service_package = dir.path().join("my-service-plugin.yoi-plugin");
+        let service_pack_json = render_pack(
+            &service_destination,
+            Some(&service_package),
+            &PluginCliArgs {
+                json: true,
+                ..PluginCliArgs::default()
+            },
+        )
+        .unwrap();
+        let service_pack_value: serde_json::Value =
+            serde_json::from_str(&service_pack_json).unwrap();
+        assert_eq!(service_pack_value["status"], "packed");
+        assert!(service_package.is_file());
+
         let error = render_new(
             "rust-component-tool",
             &destination,