nextclaw 0.45.5 → 0.47.0

package/resources/apps/nextclaw-github-issue-watcher/guest/src/lib.rs

@@ -0,0 +1,307 @@
+#[allow(warnings)]
+mod bindings;
+
+use bindings::exports::nextclaw::portable_service::service::{Action, Guest};
+use bindings::wasi::{
+    clocks::wall_clock,
+    config::store as config_store,
+    http::{
+        outgoing_handler,
+        types::{Fields, Method, OutgoingBody, OutgoingRequest, RequestOptions, Scheme},
+    },
+    io::streams::StreamError,
+    keyvalue::store as keyvalue_store,
+};
+use serde_json::{Value, json};
+
+const STORE_NAME: &str = "default";
+const SNAPSHOT_KEY: &str = "github-issues/snapshot";
+const GITHUB_TOKEN_SLOT: &str = "github-token";
+const MAX_RESPONSE_BYTES: usize = 512 * 1024;
+const REQUEST_TIMEOUT_MS: u64 = 10_000;
+
+struct Watcher;
+
+impl Guest for Watcher {
+    fn list_actions() -> Vec<Action> {
+        vec![
+            Action {
+                name: "issues_sync".into(),
+                title: "同步 GitHub Issue".into(),
+                description: "从 GitHub 同步一个仓库最近的 Issue，并保存在此应用自己的数据中。"
+                    .into(),
+            },
+            Action {
+                name: "issues_list".into(),
+                title: "查看已同步 Issue".into(),
+                description: "读取本应用上次同步的 Issue；可按打开、关闭或全部筛选。".into(),
+            },
+        ]
+    }
+
+    fn invoke(action: String, input_json: String) -> Result<String, String> {
+        let input: Value = serde_json::from_str(&input_json)
+            .map_err(|_| "INVALID_INPUT: input must be a JSON object".to_string())?;
+        match action.as_str() {
+            "issues_sync" => sync_issues(&input),
+            "issues_list" => list_issues(&input),
+            _ => Err(format!("UNKNOWN_ACTION: {action}")),
+        }
+    }
+
+    fn start(_config_json: String) -> Result<String, String> {
+        Ok(json!({ "started": true, "mode": "action" }).to_string())
+    }
+
+    fn handle_event(_event_json: String) -> Result<String, String> {
+        Err("UNSUPPORTED_LIFECYCLE: this app only responds when you request a sync or list".into())
+    }
+
+    fn stop(_reason_json: String) -> Result<String, String> {
+        Ok(json!({ "stopped": true, "mode": "action" }).to_string())
+    }
+}
+
+fn sync_issues(input: &Value) -> Result<String, String> {
+    let repository = normalized_repository(input.get("repository").and_then(Value::as_str))?;
+    let token = optional_github_token()?;
+    let response = github_issues_request(&repository, token.as_deref())?;
+    if !(200..300).contains(&response.status) {
+        return Err(format!(
+            "GITHUB_HTTP_{}: GitHub did not accept this repository request",
+            response.status
+        ));
+    }
+    let remote_issues: Value = serde_json::from_slice(&response.body).map_err(|_| {
+        "GITHUB_RESPONSE_INVALID: GitHub returned an unexpected response".to_string()
+    })?;
+    let issues = remote_issues
+        .as_array()
+        .ok_or("GITHUB_RESPONSE_INVALID: GitHub Issue response must be a list")?
+        .iter()
+        // GitHub returns pull requests from the Issue endpoint too. This app is deliberately
+        // an Issue watcher, so do not present PRs as Issues.
+        .filter(|issue| issue.get("pull_request").is_none())
+        .map(public_issue)
+        .collect::<Vec<_>>();
+    let now = wall_clock::now();
+    let snapshot = json!({
+        "repository": repository,
+        "issues": issues,
+        "syncedAtEpochMs": now.seconds.saturating_mul(1_000).saturating_add(u64::from(now.nanoseconds) / 1_000_000),
+        "source": "github-api",
+    });
+    let bucket = keyvalue_store::open(STORE_NAME).map_err(format_keyvalue_error)?;
+    bucket
+        .set(SNAPSHOT_KEY, snapshot.to_string().as_bytes())
+        .map_err(format_keyvalue_error)?;
+    Ok(json!({
+        "repository": snapshot["repository"],
+        "synced": true,
+        "issueCount": snapshot["issues"].as_array().map_or(0, Vec::len),
+        "syncedAtEpochMs": snapshot["syncedAtEpochMs"],
+        "authenticated": token.is_some(),
+        "persistedBy": "wasi:keyvalue/store",
+        "requestedVia": "wasi:http/outgoing-handler",
+    })
+    .to_string())
+}
+
+fn list_issues(input: &Value) -> Result<String, String> {
+    let state = input.get("state").and_then(Value::as_str).unwrap_or("open");
+    if !matches!(state, "open" | "closed" | "all") {
+        return Err("INVALID_INPUT: state must be open, closed, or all".into());
+    }
+    let bucket = keyvalue_store::open(STORE_NAME).map_err(format_keyvalue_error)?;
+    let saved = bucket.get(SNAPSHOT_KEY).map_err(format_keyvalue_error)?;
+    let Some(saved) = saved else {
+        return Ok(json!({
+            "repository": null,
+            "issues": [],
+            "syncedAtEpochMs": null,
+            "message": "还没有同步过仓库。先输入 owner/repository 后点击同步。",
+            "persistedBy": "wasi:keyvalue/store",
+        })
+        .to_string());
+    };
+    let mut snapshot: Value = serde_json::from_slice(&saved)
+        .map_err(|_| "STORAGE_CORRUPT: saved Issue data is not valid JSON".to_string())?;
+    let filtered = snapshot["issues"]
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter(|issue| state == "all" || issue.get("state").and_then(Value::as_str) == Some(state))
+        .cloned()
+        .collect::<Vec<_>>();
+    snapshot["issues"] = Value::Array(filtered);
+    snapshot["filter"] = Value::String(state.into());
+    snapshot["persistedBy"] = Value::String("wasi:keyvalue/store".into());
+    Ok(snapshot.to_string())
+}
+
+fn normalized_repository(value: Option<&str>) -> Result<String, String> {
+    let repository = value.unwrap_or("").trim();
+    let mut segments = repository.split('/');
+    let (Some(owner), Some(name), None) = (segments.next(), segments.next(), segments.next())
+    else {
+        return Err("INVALID_INPUT: repository must be owner/repository".into());
+    };
+    if owner.is_empty()
+        || name.is_empty()
+        || owner.len() > 100
+        || name.len() > 100
+        || !owner.chars().all(is_github_name_character)
+        || !name.chars().all(is_github_name_character)
+    {
+        return Err(
+            "INVALID_INPUT: repository must contain only GitHub owner/repository characters".into(),
+        );
+    }
+    Ok(format!("{owner}/{name}"))
+}
+
+fn is_github_name_character(character: char) -> bool {
+    character.is_ascii_alphanumeric() || matches!(character, '-' | '_' | '.')
+}
+
+fn optional_github_token() -> Result<Option<String>, String> {
+    let variable = spin_secret_variable_name(GITHUB_TOKEN_SLOT);
+    config_store::get(&variable)
+        .map_err(|_| "SECRET_UNAVAILABLE: the optional GitHub token could not be read".to_string())
+}
+
+fn spin_secret_variable_name(slot: &str) -> String {
+    format!(
+        "nextclaw_secret_{}",
+        slot.as_bytes()
+            .iter()
+            .map(|byte| format!("{byte:02x}"))
+            .collect::<String>()
+    )
+}
+
+struct HttpResponse {
+    status: u16,
+    body: Vec<u8>,
+}
+
+fn github_issues_request(repository: &str, token: Option<&str>) -> Result<HttpResponse, String> {
+    let fields = Fields::new();
+    fields
+        .append("accept", b"application/vnd.github+json")
+        .map_err(|_| "WASI_HTTP_REQUEST_INVALID: GitHub accept header".to_string())?;
+    fields
+        .append("user-agent", b"NextClaw-GitHub-Issue-Watcher")
+        .map_err(|_| "WASI_HTTP_REQUEST_INVALID: GitHub user-agent header".to_string())?;
+    fields
+        .append("x-github-api-version", b"2022-11-28")
+        .map_err(|_| "WASI_HTTP_REQUEST_INVALID: GitHub API version header".to_string())?;
+    if let Some(token) = token.filter(|token| !token.trim().is_empty()) {
+        let authorization = format!("Bearer {token}");
+        fields
+            .append("authorization", authorization.as_bytes())
+            .map_err(|_| "WASI_HTTP_REQUEST_INVALID: GitHub authorization header".to_string())?;
+    }
+    let request = OutgoingRequest::new(fields);
+    request
+        .set_method(&Method::Get)
+        .map_err(|_| "WASI_HTTP_REQUEST_INVALID: GET method was rejected".to_string())?;
+    request
+        .set_scheme(Some(&Scheme::Https))
+        .map_err(|_| "WASI_HTTP_REQUEST_INVALID: HTTPS scheme was rejected".to_string())?;
+    request
+        .set_authority(Some("api.github.com"))
+        .map_err(|_| "WASI_HTTP_REQUEST_INVALID: GitHub authority was rejected".to_string())?;
+    request
+        .set_path_with_query(Some(&format!(
+            "/repos/{repository}/issues?state=all&per_page=20&sort=updated&direction=desc"
+        )))
+        .map_err(|_| "WASI_HTTP_REQUEST_INVALID: GitHub path was rejected".to_string())?;
+    let body = request
+        .body()
+        .map_err(|_| "WASI_HTTP_REQUEST_INVALID: request body unavailable".to_string())?;
+    OutgoingBody::finish(body, None).map_err(format_wasi_http_error)?;
+
+    let options = RequestOptions::new();
+    let timeout_ns = REQUEST_TIMEOUT_MS * 1_000_000;
+    options
+        .set_connect_timeout(Some(timeout_ns))
+        .map_err(|_| "WASI_HTTP_TIMEOUT_UNSUPPORTED: connect timeout".to_string())?;
+    options
+        .set_first_byte_timeout(Some(timeout_ns))
+        .map_err(|_| "WASI_HTTP_TIMEOUT_UNSUPPORTED: first-byte timeout".to_string())?;
+    options
+        .set_between_bytes_timeout(Some(timeout_ns))
+        .map_err(|_| "WASI_HTTP_TIMEOUT_UNSUPPORTED: between-bytes timeout".to_string())?;
+    let pending =
+        outgoing_handler::handle(request, Some(options)).map_err(format_wasi_http_error)?;
+    let response = loop {
+        match pending.get() {
+            Some(Ok(Ok(response))) => break response,
+            Some(Ok(Err(error))) => return Err(format_wasi_http_error(error)),
+            Some(Err(())) => return Err("WASI_HTTP_RESPONSE_ALREADY_CONSUMED".into()),
+            None => pending.subscribe().block(),
+        }
+    };
+    let status = response.status();
+    let body = response
+        .consume()
+        .map_err(|_| "WASI_HTTP_RESPONSE_BODY_UNAVAILABLE".to_string())?;
+    let stream = body
+        .stream()
+        .map_err(|_| "WASI_HTTP_RESPONSE_STREAM_UNAVAILABLE".to_string())?;
+    Ok(HttpResponse {
+        status,
+        body: read_response_body(stream)?,
+    })
+}
+
+fn read_response_body(stream: bindings::wasi::io::streams::InputStream) -> Result<Vec<u8>, String> {
+    let mut body = Vec::new();
+    loop {
+        match stream.read(8 * 1024) {
+            Ok(chunk) if chunk.is_empty() => stream.subscribe().block(),
+            Ok(chunk) => {
+                let next_length = body
+                    .len()
+                    .checked_add(chunk.len())
+                    .ok_or("GITHUB_RESPONSE_TOO_LARGE: response size overflow")?;
+                if next_length > MAX_RESPONSE_BYTES {
+                    return Err("GITHUB_RESPONSE_TOO_LARGE: GitHub response exceeds 512 KiB".into());
+                }
+                body.extend_from_slice(&chunk);
+            }
+            Err(StreamError::Closed) => return Ok(body),
+            Err(StreamError::LastOperationFailed(_)) => {
+                return Err("WASI_HTTP_RESPONSE_STREAM_FAILED".into());
+            }
+        }
+    }
+}
+
+fn public_issue(issue: &Value) -> Value {
+    json!({
+        "number": issue.get("number").and_then(Value::as_u64),
+        "title": issue.get("title").and_then(Value::as_str).unwrap_or("未命名 Issue"),
+        "state": issue.get("state").and_then(Value::as_str).unwrap_or("open"),
+        "url": issue.get("html_url").and_then(Value::as_str),
+        "updatedAt": issue.get("updated_at").and_then(Value::as_str),
+        "author": issue.pointer("/user/login").and_then(Value::as_str),
+        "labels": issue.get("labels").and_then(Value::as_array).map(|labels| labels.iter()
+            .filter_map(|label| label.get("name").and_then(Value::as_str))
+            .collect::<Vec<_>>()).unwrap_or_default(),
+    })
+}
+
+fn format_wasi_http_error(error: bindings::wasi::http::types::ErrorCode) -> String {
+    // WASI HTTP error variants contain transport policy facts, not request
+    // headers. Keeping the variant makes a blocked domain/DNS/timeout
+    // actionable without ever exposing an optional GitHub token.
+    format!("WASI_HTTP_ERROR: {error:?}")
+}
+
+fn format_keyvalue_error(_error: keyvalue_store::Error) -> String {
+    "WASI_KEYVALUE_ERROR: application storage is unavailable".into()
+}
+
+bindings::export!(Watcher with_types_in bindings);

package/resources/apps/nextclaw-github-issue-watcher/guest/wit/deps/clocks@0.2.6/monotonic-clock.wit

@@ -0,0 +1,50 @@
+package wasi:clocks@0.2.6;
+/// WASI Monotonic Clock is a clock API intended to let users measure elapsed
+/// time.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+///
+/// A monotonic clock is a clock which has an unspecified initial value, and
+/// successive reads of the clock will produce non-decreasing values.
+@since(version = 0.2.0)
+interface monotonic-clock {
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.6.{pollable};
+
+    /// An instant in time, in nanoseconds. An instant is relative to an
+    /// unspecified initial value, and can only be compared to instances from
+    /// the same monotonic-clock.
+    @since(version = 0.2.0)
+    type instant = u64;
+
+    /// A duration of time, in nanoseconds.
+    @since(version = 0.2.0)
+    type duration = u64;
+
+    /// Read the current value of the clock.
+    ///
+    /// The clock is monotonic, therefore calling this function repeatedly will
+    /// produce a sequence of non-decreasing values.
+    @since(version = 0.2.0)
+    now: func() -> instant;
+
+    /// Query the resolution of the clock. Returns the duration of time
+    /// corresponding to a clock tick.
+    @since(version = 0.2.0)
+    resolution: func() -> duration;
+
+    /// Create a `pollable` which will resolve once the specified instant
+    /// has occurred.
+    @since(version = 0.2.0)
+    subscribe-instant: func(
+        when: instant,
+    ) -> pollable;
+
+    /// Create a `pollable` that will resolve after the specified duration has
+    /// elapsed from the time this function is invoked.
+    @since(version = 0.2.0)
+    subscribe-duration: func(
+        when: duration,
+    ) -> pollable;
+}

package/resources/apps/nextclaw-github-issue-watcher/guest/wit/deps/clocks@0.2.6/timezone.wit

@@ -0,0 +1,55 @@
+package wasi:clocks@0.2.6;
+
+@unstable(feature = clocks-timezone)
+interface timezone {
+    @unstable(feature = clocks-timezone)
+    use wall-clock.{datetime};
+
+    /// Return information needed to display the given `datetime`. This includes
+    /// the UTC offset, the time zone name, and a flag indicating whether
+    /// daylight saving time is active.
+    ///
+    /// If the timezone cannot be determined for the given `datetime`, return a
+    /// `timezone-display` for `UTC` with a `utc-offset` of 0 and no daylight
+    /// saving time.
+    @unstable(feature = clocks-timezone)
+    display: func(when: datetime) -> timezone-display;
+
+    /// The same as `display`, but only return the UTC offset.
+    @unstable(feature = clocks-timezone)
+    utc-offset: func(when: datetime) -> s32;
+
+    /// Information useful for displaying the timezone of a specific `datetime`.
+    ///
+    /// This information may vary within a single `timezone` to reflect daylight
+    /// saving time adjustments.
+    @unstable(feature = clocks-timezone)
+    record timezone-display {
+        /// The number of seconds difference between UTC time and the local
+        /// time of the timezone.
+        ///
+        /// The returned value will always be less than 86400 which is the
+        /// number of seconds in a day (24*60*60).
+        ///
+        /// In implementations that do not expose an actual time zone, this
+        /// should return 0.
+        utc-offset: s32,
+
+        /// The abbreviated name of the timezone to display to a user. The name
+        /// `UTC` indicates Coordinated Universal Time. Otherwise, this should
+        /// reference local standards for the name of the time zone.
+        ///
+        /// In implementations that do not expose an actual time zone, this
+        /// should be the string `UTC`.
+        ///
+        /// In time zones that do not have an applicable name, a formatted
+        /// representation of the UTC offset may be returned, such as `-04:00`.
+        name: string,
+
+        /// Whether daylight saving time is active.
+        ///
+        /// In implementations that do not expose an actual time zone, this
+        /// should return false.
+        in-daylight-saving-time: bool,
+    }
+}

package/resources/apps/nextclaw-github-issue-watcher/guest/wit/deps/clocks@0.2.6/wall-clock.wit

@@ -0,0 +1,46 @@
+package wasi:clocks@0.2.6;
+/// WASI Wall Clock is a clock API intended to let users query the current
+/// time. The name "wall" makes an analogy to a "clock on the wall", which
+/// is not necessarily monotonic as it may be reset.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+///
+/// A wall clock is a clock which measures the date and time according to
+/// some external reference.
+///
+/// External references may be reset, so this clock is not necessarily
+/// monotonic, making it unsuitable for measuring elapsed time.
+///
+/// It is intended for reporting the current date and time for humans.
+@since(version = 0.2.0)
+interface wall-clock {
+    /// A time and date in seconds plus nanoseconds.
+    @since(version = 0.2.0)
+    record datetime {
+        seconds: u64,
+        nanoseconds: u32,
+    }
+
+    /// Read the current value of the clock.
+    ///
+    /// This clock is not monotonic, therefore calling this function repeatedly
+    /// will not necessarily produce a sequence of non-decreasing values.
+    ///
+    /// The returned timestamps represent the number of seconds since
+    /// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+    /// also known as [Unix Time].
+    ///
+    /// The nanoseconds field of the output is always less than 1000000000.
+    ///
+    /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+    /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+    @since(version = 0.2.0)
+    now: func() -> datetime;
+
+    /// Query the resolution of the clock.
+    ///
+    /// The nanoseconds field of the output is always less than 1000000000.
+    @since(version = 0.2.0)
+    resolution: func() -> datetime;
+}

package/resources/apps/nextclaw-github-issue-watcher/guest/wit/deps/clocks@0.2.6/world.wit

@@ -0,0 +1,11 @@
+package wasi:clocks@0.2.6;
+
+@since(version = 0.2.0)
+world imports {
+    @since(version = 0.2.0)
+    import monotonic-clock;
+    @since(version = 0.2.0)
+    import wall-clock;
+    @unstable(feature = clocks-timezone)
+    import timezone;
+}

package/resources/apps/nextclaw-github-issue-watcher/guest/wit/deps/config@0.2.0-draft-2024-09-27/package.wit

@@ -0,0 +1 @@
+package wasi:config@0.2.0-draft-2024-09-27;

package/resources/apps/nextclaw-github-issue-watcher/guest/wit/deps/config@0.2.0-draft-2024-09-27/store.wit

@@ -0,0 +1,9 @@
+interface store {
+  variant error {
+    upstream(string),
+    io(string),
+  }
+
+  get: func(key: string) -> result<option<string>, error>;
+  get-all: func() -> result<list<tuple<string, string>>, error>;
+}

package/resources/apps/nextclaw-github-issue-watcher/guest/wit/deps/http@0.2.6/handler.wit

@@ -0,0 +1,49 @@
+/// This interface defines a handler of incoming HTTP Requests. It should
+/// be exported by components which can respond to HTTP Requests.
+@since(version = 0.2.0)
+interface incoming-handler {
+  @since(version = 0.2.0)
+  use types.{incoming-request, response-outparam};
+
+  /// This function is invoked with an incoming HTTP Request, and a resource
+  /// `response-outparam` which provides the capability to reply with an HTTP
+  /// Response. The response is sent by calling the `response-outparam.set`
+  /// method, which allows execution to continue after the response has been
+  /// sent. This enables both streaming to the response body, and performing other
+  /// work.
+  ///
+  /// The implementor of this function must write a response to the
+  /// `response-outparam` before returning, or else the caller will respond
+  /// with an error on its behalf.
+  @since(version = 0.2.0)
+  handle: func(
+    request: incoming-request,
+    response-out: response-outparam
+  );
+}
+
+/// This interface defines a handler of outgoing HTTP Requests. It should be
+/// imported by components which wish to make HTTP Requests.
+@since(version = 0.2.0)
+interface outgoing-handler {
+  @since(version = 0.2.0)
+  use types.{
+    outgoing-request, request-options, future-incoming-response, error-code
+  };
+
+  /// This function is invoked with an outgoing HTTP Request, and it returns
+  /// a resource `future-incoming-response` which represents an HTTP Response
+  /// which may arrive in the future.
+  ///
+  /// The `options` argument accepts optional parameters for the HTTP
+  /// protocol's transport layer.
+  ///
+  /// This function may return an error if the `outgoing-request` is invalid
+  /// or not allowed to be made. Otherwise, protocol errors are reported
+  /// through the `future-incoming-response`.
+  @since(version = 0.2.0)
+  handle: func(
+    request: outgoing-request,
+    options: option<request-options>
+  ) -> result<future-incoming-response, error-code>;
+}

package/resources/apps/nextclaw-github-issue-watcher/guest/wit/deps/http@0.2.6/package.wit

@@ -0,0 +1 @@
+package wasi:http@0.2.6;