reallink-cli 0.1.14 → 0.1.16

package/rust/src/unreal.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use clap::{ArgAction, Args, Subcommand};
+use clap::{ArgAction, Args, Subcommand, ValueEnum};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
@@ -74,6 +74,15 @@ pub(crate) enum LinkCommands {
         #[command(subcommand)]
         command: LinkPluginCommands,
     },
+    /// Register a local source folder for a project
+    Source(LinkSourceArgs),
+    /// Connect to Reallink and bridge local source to agents
+    Connect(LinkConnectArgs),
+    /// Manage P2P signaling sessions for direct CLI-to-CLI transports
+    P2p {
+        #[command(subcommand)]
+        command: LinkP2PCommands,
+    },
 }
 
 #[derive(Subcommand)]
@@ -82,6 +91,15 @@ pub(crate) enum LinkPluginCommands {
     List(LinkPluginListArgs),
 }
 
+#[derive(Subcommand)]
+pub(crate) enum LinkP2PCommands {
+    Create(LinkP2PCreateArgs),
+    List(LinkP2PListArgs),
+    Get(LinkP2PGetArgs),
+    Wait(LinkP2PWaitArgs),
+    Signal(LinkP2PSignalArgs),
+}
+
 #[derive(Args)]
 pub(crate) struct LinkUnrealArgs {
     #[arg(long, help = "Remote Reallink project id to bind")]
@@ -247,6 +265,200 @@ pub(crate) struct LinkPluginListArgs {
     pub index_path: String,
 }
 
+// ---------------------------------------------------------------------------
+// Source link args
+// ---------------------------------------------------------------------------
+
+#[derive(Args)]
+pub(crate) struct LinkSourceArgs {
+    #[arg(long, help = "Project ID to bind the source folder to")]
+    pub project_id: String,
+    #[arg(long, help = "Local directory path containing source files")]
+    pub path: PathBuf,
+    #[arg(
+        long,
+        default_value = "project",
+        help = "Label for this folder (project, engine, etc.)"
+    )]
+    pub label: String,
+    #[arg(long)]
+    pub base_url: Option<String>,
+}
+
+#[derive(Args)]
+pub(crate) struct LinkConnectArgs {
+    #[arg(long, help = "Project ID to connect. Uses default if omitted")]
+    pub project_id: Option<String>,
+    #[arg(
+        long,
+        help = "Stable workspace identifier for this linked client session"
+    )]
+    pub workspace_id: Option<String>,
+    #[arg(long, help = "Push file index + key source files to R2 on connect")]
+    pub sync: bool,
+    #[arg(
+        long,
+        default_value = "websocket",
+        help = "Transport used by this linked client session"
+    )]
+    pub transport: String,
+    #[arg(long, help = "Connect service URL override")]
+    pub connect_url: Option<String>,
+    #[arg(long)]
+    pub base_url: Option<String>,
+    #[arg(long, help = "Bearer token override for agent/API-token usage")]
+    pub access_token: Option<String>,
+}
+
+#[derive(Clone, Debug, ValueEnum)]
+pub(crate) enum LinkP2PRole {
+    Agent,
+    Client,
+}
+
+impl LinkP2PRole {
+    pub(crate) fn as_api_str(&self) -> &'static str {
+        match self {
+            Self::Agent => "agent",
+            Self::Client => "client",
+        }
+    }
+}
+
+#[derive(Clone, Debug, ValueEnum)]
+pub(crate) enum LinkP2PSignalType {
+    Offer,
+    Answer,
+    Candidate,
+    Ready,
+}
+
+impl LinkP2PSignalType {
+    pub(crate) fn as_api_str(&self) -> &'static str {
+        match self {
+            Self::Offer => "offer",
+            Self::Answer => "answer",
+            Self::Candidate => "candidate",
+            Self::Ready => "ready",
+        }
+    }
+}
+
+#[derive(Args)]
+pub(crate) struct LinkP2PCreateArgs {
+    #[arg(long, help = "Project ID to attach the P2P session to")]
+    pub project_id: String,
+    #[arg(long, help = "Stable workspace identifier for this P2P session")]
+    pub workspace_id: Option<String>,
+    #[arg(
+        long,
+        help = "Optional source clientId already registered under the workspace"
+    )]
+    pub client_id: Option<String>,
+    #[arg(long, help = "Optional peer clientId expected to join this session")]
+    pub peer_client_id: Option<String>,
+    #[arg(long, help = "Session TTL in seconds")]
+    pub ttl_seconds: Option<u64>,
+    #[arg(
+        long,
+        help = "Inline JSON object or @path/to/file.json with additional metadata"
+    )]
+    pub metadata: Option<String>,
+    #[arg(long)]
+    pub base_url: Option<String>,
+    #[arg(long, help = "Bearer token override for agent/API-token usage")]
+    pub access_token: Option<String>,
+}
+
+#[derive(Args)]
+pub(crate) struct LinkP2PGetArgs {
+    #[arg(long, help = "Project ID owning the P2P session")]
+    pub project_id: String,
+    #[arg(long, help = "P2P session identifier")]
+    pub session_id: String,
+    #[arg(long)]
+    pub base_url: Option<String>,
+    #[arg(long, help = "Bearer token override for agent/API-token usage")]
+    pub access_token: Option<String>,
+}
+
+#[derive(Args)]
+pub(crate) struct LinkP2PListArgs {
+    #[arg(long, help = "Project ID owning the P2P sessions")]
+    pub project_id: String,
+    #[arg(long)]
+    pub workspace_id: Option<String>,
+    #[arg(long)]
+    pub client_id: Option<String>,
+    #[arg(long)]
+    pub status: Option<String>,
+    #[arg(long, default_value_t = 50)]
+    pub limit: u32,
+    #[arg(long)]
+    pub base_url: Option<String>,
+    #[arg(long, help = "Bearer token override for agent/API-token usage")]
+    pub access_token: Option<String>,
+}
+
+#[derive(Args)]
+pub(crate) struct LinkP2PWaitArgs {
+    #[arg(long, help = "Project ID owning the P2P session")]
+    pub project_id: String,
+    #[arg(long, help = "P2P session identifier")]
+    pub session_id: String,
+    #[arg(long, default_value = "ready")]
+    pub status: String,
+    #[arg(long, default_value_t = 30_000)]
+    pub timeout_ms: u64,
+    #[arg(long, default_value_t = 1_000)]
+    pub poll_interval_ms: u64,
+    #[arg(long)]
+    pub base_url: Option<String>,
+    #[arg(long, help = "Bearer token override for agent/API-token usage")]
+    pub access_token: Option<String>,
+}
+
+#[derive(Args)]
+pub(crate) struct LinkP2PSignalArgs {
+    #[arg(long, help = "Project ID owning the P2P session")]
+    pub project_id: String,
+    #[arg(long, help = "P2P session identifier")]
+    pub session_id: String,
+    #[arg(long, value_enum)]
+    pub role: LinkP2PRole,
+    #[arg(long = "signal-type", value_enum)]
+    pub signal_type: LinkP2PSignalType,
+    #[arg(
+        long,
+        help = "Inline JSON object or @path/to/file.json carrying the signal payload"
+    )]
+    pub payload: String,
+    #[arg(long, help = "Idempotency key for this signal")]
+    pub signal_id: Option<String>,
+    #[arg(long, help = "Optional registered clientId originating this signal")]
+    pub from_client_id: Option<String>,
+    #[arg(long)]
+    pub base_url: Option<String>,
+    #[arg(long, help = "Bearer token override for agent/API-token usage")]
+    pub access_token: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct SourceLinkRecord {
+    pub project_id: String,
+    pub folder_path: String,
+    pub folder_label: String,
+    pub created_at_epoch_ms: u128,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, Default)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct SourceLinksConfig {
+    pub version: u32,
+    pub links: Vec<SourceLinkRecord>,
+}
+
 pub(crate) async fn dispatch(client: &reqwest::Client, command: LinkCommands) -> Result<()> {
     match command {
         LinkCommands::Unreal(args) => crate::link_unreal_command(client, args).await?,
@@ -258,9 +470,20 @@ pub(crate) async fn dispatch(client: &reqwest::Client, command: LinkCommands) ->
         LinkCommands::Open(args) => crate::link_open_command(args).await?,
         LinkCommands::Run(args) => crate::link_run_command(args).await?,
         LinkCommands::Plugin { command } => match command {
-            LinkPluginCommands::Install(args) => crate::link_plugin_install_command(client, args).await?,
+            LinkPluginCommands::Install(args) => {
+                crate::link_plugin_install_command(client, args).await?
+            }
             LinkPluginCommands::List(args) => crate::link_plugin_list_command(client, args).await?,
         },
+        LinkCommands::Source(args) => crate::link_source_command(client, args).await?,
+        LinkCommands::Connect(args) => crate::link_connect_command(client, args).await?,
+        LinkCommands::P2p { command } => match command {
+            LinkP2PCommands::Create(args) => crate::link_p2p_create_command(client, args).await?,
+            LinkP2PCommands::List(args) => crate::link_p2p_list_command(client, args).await?,
+            LinkP2PCommands::Get(args) => crate::link_p2p_get_command(client, args).await?,
+            LinkP2PCommands::Wait(args) => crate::link_p2p_wait_command(client, args).await?,
+            LinkP2PCommands::Signal(args) => crate::link_p2p_signal_command(client, args).await?,
+        },
     }
     Ok(())
 }

package/scripts/postinstall.cjs

@@ -25,7 +25,7 @@ if (process.env.REALLINK_SKIP_BUILD === "1") {
   process.exit(0);
 }
 
-if (hasReleaseBinary() || fs.existsSync(prebuiltBinaryPath)) {
+if (process.env.REALLINK_FORCE_BUILD !== "1" && (hasReleaseBinary() || fs.existsSync(prebuiltBinaryPath))) {
   process.exit(0);
 }