nextclaw 0.46.0 → 0.47.0

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

@@ -0,0 +1,34 @@
+package wasi:io@0.2.6;
+
+@since(version = 0.2.0)
+interface error {
+    /// A resource which represents some error information.
+    ///
+    /// The only method provided by this resource is `to-debug-string`,
+    /// which provides some human-readable information about the error.
+    ///
+    /// In the `wasi:io` package, this resource is returned through the
+    /// `wasi:io/streams/stream-error` type.
+    ///
+    /// To provide more specific error information, other interfaces may
+    /// offer functions to "downcast" this error into more specific types. For example,
+    /// errors returned from streams derived from filesystem types can be described using
+    /// the filesystem's own error-code type. This is done using the function
+    /// `wasi:filesystem/types/filesystem-error-code`, which takes a `borrow<error>`
+    /// parameter and returns an `option<wasi:filesystem/types/error-code>`.
+    ///
+    /// The set of functions which can "downcast" an `error` into a more
+    /// concrete type is open.
+    @since(version = 0.2.0)
+    resource error {
+        /// Returns a string that is suitable to assist humans in debugging
+        /// this error.
+        ///
+        /// WARNING: The returned string should not be consumed mechanically!
+        /// It may change across platforms, hosts, or other implementation
+        /// details. Parsing this string is a major platform-compatibility
+        /// hazard.
+        @since(version = 0.2.0)
+        to-debug-string: func() -> string;
+    }
+}

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

@@ -0,0 +1,47 @@
+package wasi:io@0.2.6;
+
+/// A poll API intended to let users wait for I/O events on multiple handles
+/// at once.
+@since(version = 0.2.0)
+interface poll {
+    /// `pollable` represents a single I/O event which may be ready, or not.
+    @since(version = 0.2.0)
+    resource pollable {
+
+        /// Return the readiness of a pollable. This function never blocks.
+        ///
+        /// Returns `true` when the pollable is ready, and `false` otherwise.
+        @since(version = 0.2.0)
+        ready: func() -> bool;
+
+        /// `block` returns immediately if the pollable is ready, and otherwise
+        /// blocks until ready.
+        ///
+        /// This function is equivalent to calling `poll.poll` on a list
+        /// containing only this pollable.
+        @since(version = 0.2.0)
+        block: func();
+    }
+
+    /// Poll for completion on a set of pollables.
+    ///
+    /// This function takes a list of pollables, which identify I/O sources of
+    /// interest, and waits until one or more of the events is ready for I/O.
+    ///
+    /// The result `list<u32>` contains one or more indices of handles in the
+    /// argument list that is ready for I/O.
+    ///
+    /// This function traps if either:
+    /// - the list is empty, or:
+    /// - the list contains more elements than can be indexed with a `u32` value.
+    ///
+    /// A timeout can be implemented by adding a pollable from the
+    /// wasi-clocks API to the list.
+    ///
+    /// This function does not return a `result`; polling in itself does not
+    /// do any I/O so it doesn't fail. If any of the I/O sources identified by
+    /// the pollables has an error, it is indicated by marking the source as
+    /// being ready for I/O.
+    @since(version = 0.2.0)
+    poll: func(in: list<borrow<pollable>>) -> list<u32>;
+}

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

@@ -0,0 +1,290 @@
+package wasi:io@0.2.6;
+
+/// WASI I/O is an I/O abstraction API which is currently focused on providing
+/// stream types.
+///
+/// In the future, the component model is expected to add built-in stream types;
+/// when it does, they are expected to subsume this API.
+@since(version = 0.2.0)
+interface streams {
+    @since(version = 0.2.0)
+    use error.{error};
+    @since(version = 0.2.0)
+    use poll.{pollable};
+
+    /// An error for input-stream and output-stream operations.
+    @since(version = 0.2.0)
+    variant stream-error {
+        /// The last operation (a write or flush) failed before completion.
+        ///
+        /// More information is available in the `error` payload.
+        ///
+        /// After this, the stream will be closed. All future operations return
+        /// `stream-error::closed`.
+        last-operation-failed(error),
+        /// The stream is closed: no more input will be accepted by the
+        /// stream. A closed output-stream will return this error on all
+        /// future operations.
+        closed
+    }
+
+    /// An input bytestream.
+    ///
+    /// `input-stream`s are *non-blocking* to the extent practical on underlying
+    /// platforms. I/O operations always return promptly; if fewer bytes are
+    /// promptly available than requested, they return the number of bytes promptly
+    /// available, which could even be zero. To wait for data to be available,
+    /// use the `subscribe` function to obtain a `pollable` which can be polled
+    /// for using `wasi:io/poll`.
+    @since(version = 0.2.0)
+    resource input-stream {
+        /// Perform a non-blocking read from the stream.
+        ///
+        /// When the source of a `read` is binary data, the bytes from the source
+        /// are returned verbatim. When the source of a `read` is known to the
+        /// implementation to be text, bytes containing the UTF-8 encoding of the
+        /// text are returned.
+        ///
+        /// This function returns a list of bytes containing the read data,
+        /// when successful. The returned list will contain up to `len` bytes;
+        /// it may return fewer than requested, but not more. The list is
+        /// empty when no bytes are available for reading at this time. The
+        /// pollable given by `subscribe` will be ready when more bytes are
+        /// available.
+        ///
+        /// This function fails with a `stream-error` when the operation
+        /// encounters an error, giving `last-operation-failed`, or when the
+        /// stream is closed, giving `closed`.
+        ///
+        /// When the caller gives a `len` of 0, it represents a request to
+        /// read 0 bytes. If the stream is still open, this call should
+        /// succeed and return an empty list, or otherwise fail with `closed`.
+        ///
+        /// The `len` parameter is a `u64`, which could represent a list of u8 which
+        /// is not possible to allocate in wasm32, or not desirable to allocate as
+        /// as a return value by the callee. The callee may return a list of bytes
+        /// less than `len` in size while more bytes are available for reading.
+        @since(version = 0.2.0)
+        read: func(
+            /// The maximum number of bytes to read
+            len: u64
+        ) -> result<list<u8>, stream-error>;
+
+        /// Read bytes from a stream, after blocking until at least one byte can
+        /// be read. Except for blocking, behavior is identical to `read`.
+        @since(version = 0.2.0)
+        blocking-read: func(
+            /// The maximum number of bytes to read
+            len: u64
+        ) -> result<list<u8>, stream-error>;
+
+        /// Skip bytes from a stream. Returns number of bytes skipped.
+        ///
+        /// Behaves identical to `read`, except instead of returning a list
+        /// of bytes, returns the number of bytes consumed from the stream.
+        @since(version = 0.2.0)
+        skip: func(
+            /// The maximum number of bytes to skip.
+            len: u64,
+        ) -> result<u64, stream-error>;
+
+        /// Skip bytes from a stream, after blocking until at least one byte
+        /// can be skipped. Except for blocking behavior, identical to `skip`.
+        @since(version = 0.2.0)
+        blocking-skip: func(
+            /// The maximum number of bytes to skip.
+            len: u64,
+        ) -> result<u64, stream-error>;
+
+        /// Create a `pollable` which will resolve once either the specified stream
+        /// has bytes available to read or the other end of the stream has been
+        /// closed.
+        /// The created `pollable` is a child resource of the `input-stream`.
+        /// Implementations may trap if the `input-stream` is dropped before
+        /// all derived `pollable`s created with this function are dropped.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
+
+
+    /// An output bytestream.
+    ///
+    /// `output-stream`s are *non-blocking* to the extent practical on
+    /// underlying platforms. Except where specified otherwise, I/O operations also
+    /// always return promptly, after the number of bytes that can be written
+    /// promptly, which could even be zero. To wait for the stream to be ready to
+    /// accept data, the `subscribe` function to obtain a `pollable` which can be
+    /// polled for using `wasi:io/poll`.
+    ///
+    /// Dropping an `output-stream` while there's still an active write in
+    /// progress may result in the data being lost. Before dropping the stream,
+    /// be sure to fully flush your writes.
+    @since(version = 0.2.0)
+    resource output-stream {
+        /// Check readiness for writing. This function never blocks.
+        ///
+        /// Returns the number of bytes permitted for the next call to `write`,
+        /// or an error. Calling `write` with more bytes than this function has
+        /// permitted will trap.
+        ///
+        /// When this function returns 0 bytes, the `subscribe` pollable will
+        /// become ready when this function will report at least 1 byte, or an
+        /// error.
+        @since(version = 0.2.0)
+        check-write: func() -> result<u64, stream-error>;
+
+        /// Perform a write. This function never blocks.
+        ///
+        /// When the destination of a `write` is binary data, the bytes from
+        /// `contents` are written verbatim. When the destination of a `write` is
+        /// known to the implementation to be text, the bytes of `contents` are
+        /// transcoded from UTF-8 into the encoding of the destination and then
+        /// written.
+        ///
+        /// Precondition: check-write gave permit of Ok(n) and contents has a
+        /// length of less than or equal to n. Otherwise, this function will trap.
+        ///
+        /// returns Err(closed) without writing if the stream has closed since
+        /// the last call to check-write provided a permit.
+        @since(version = 0.2.0)
+        write: func(
+            contents: list<u8>
+        ) -> result<_, stream-error>;
+
+        /// Perform a write of up to 4096 bytes, and then flush the stream. Block
+        /// until all of these operations are complete, or an error occurs.
+        ///
+        /// This is a convenience wrapper around the use of `check-write`,
+        /// `subscribe`, `write`, and `flush`, and is implemented with the
+        /// following pseudo-code:
+        ///
+        /// ```text
+        /// let pollable = this.subscribe();
+        /// while !contents.is_empty() {
+        ///     // Wait for the stream to become writable
+        ///     pollable.block();
+        ///     let Ok(n) = this.check-write(); // eliding error handling
+        ///     let len = min(n, contents.len());
+        ///     let (chunk, rest) = contents.split_at(len);
+        ///     this.write(chunk  );            // eliding error handling
+        ///     contents = rest;
+        /// }
+        /// this.flush();
+        /// // Wait for completion of `flush`
+        /// pollable.block();
+        /// // Check for any errors that arose during `flush`
+        /// let _ = this.check-write();         // eliding error handling
+        /// ```
+        @since(version = 0.2.0)
+        blocking-write-and-flush: func(
+            contents: list<u8>
+        ) -> result<_, stream-error>;
+
+        /// Request to flush buffered output. This function never blocks.
+        ///
+        /// This tells the output-stream that the caller intends any buffered
+        /// output to be flushed. the output which is expected to be flushed
+        /// is all that has been passed to `write` prior to this call.
+        ///
+        /// Upon calling this function, the `output-stream` will not accept any
+        /// writes (`check-write` will return `ok(0)`) until the flush has
+        /// completed. The `subscribe` pollable will become ready when the
+        /// flush has completed and the stream can accept more writes.
+        @since(version = 0.2.0)
+        flush: func() -> result<_, stream-error>;
+
+        /// Request to flush buffered output, and block until flush completes
+        /// and stream is ready for writing again.
+        @since(version = 0.2.0)
+        blocking-flush: func() -> result<_, stream-error>;
+
+        /// Create a `pollable` which will resolve once the output-stream
+        /// is ready for more writing, or an error has occurred. When this
+        /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
+        /// error.
+        ///
+        /// If the stream is closed, this pollable is always ready immediately.
+        ///
+        /// The created `pollable` is a child resource of the `output-stream`.
+        /// Implementations may trap if the `output-stream` is dropped before
+        /// all derived `pollable`s created with this function are dropped.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+
+        /// Write zeroes to a stream.
+        ///
+        /// This should be used precisely like `write` with the exact same
+        /// preconditions (must use check-write first), but instead of
+        /// passing a list of bytes, you simply pass the number of zero-bytes
+        /// that should be written.
+        @since(version = 0.2.0)
+        write-zeroes: func(
+            /// The number of zero-bytes to write
+            len: u64
+        ) -> result<_, stream-error>;
+
+        /// Perform a write of up to 4096 zeroes, and then flush the stream.
+        /// Block until all of these operations are complete, or an error
+        /// occurs.
+        ///
+        /// This is a convenience wrapper around the use of `check-write`,
+        /// `subscribe`, `write-zeroes`, and `flush`, and is implemented with
+        /// the following pseudo-code:
+        ///
+        /// ```text
+        /// let pollable = this.subscribe();
+        /// while num_zeroes != 0 {
+        ///     // Wait for the stream to become writable
+        ///     pollable.block();
+        ///     let Ok(n) = this.check-write(); // eliding error handling
+        ///     let len = min(n, num_zeroes);
+        ///     this.write-zeroes(len);         // eliding error handling
+        ///     num_zeroes -= len;
+        /// }
+        /// this.flush();
+        /// // Wait for completion of `flush`
+        /// pollable.block();
+        /// // Check for any errors that arose during `flush`
+        /// let _ = this.check-write();         // eliding error handling
+        /// ```
+        @since(version = 0.2.0)
+        blocking-write-zeroes-and-flush: func(
+            /// The number of zero-bytes to write
+            len: u64
+        ) -> result<_, stream-error>;
+
+        /// Read from one stream and write to another.
+        ///
+        /// The behavior of splice is equivalent to:
+        /// 1. calling `check-write` on the `output-stream`
+        /// 2. calling `read` on the `input-stream` with the smaller of the
+        /// `check-write` permitted length and the `len` provided to `splice`
+        /// 3. calling `write` on the `output-stream` with that read data.
+        ///
+        /// Any error reported by the call to `check-write`, `read`, or
+        /// `write` ends the splice and reports that error.
+        ///
+        /// This function returns the number of bytes transferred; it may be less
+        /// than `len`.
+        @since(version = 0.2.0)
+        splice: func(
+            /// The stream to read from
+            src: borrow<input-stream>,
+            /// The number of bytes to splice
+            len: u64,
+        ) -> result<u64, stream-error>;
+
+        /// Read from one stream and write to another, with blocking.
+        ///
+        /// This is similar to `splice`, except that it blocks until the
+        /// `output-stream` is ready for writing, and the `input-stream`
+        /// is ready for reading, before performing the `splice`.
+        @since(version = 0.2.0)
+        blocking-splice: func(
+            /// The stream to read from
+            src: borrow<input-stream>,
+            /// The number of bytes to splice
+            len: u64,
+        ) -> result<u64, stream-error>;
+    }
+}

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

@@ -0,0 +1,10 @@
+package wasi:io@0.2.6;
+
+@since(version = 0.2.0)
+world imports {
+    @since(version = 0.2.0)
+    import streams;
+
+    @since(version = 0.2.0)
+    import poll;
+}

package/resources/apps/nextclaw-github-issue-watcher/guest/wit/deps/keyvalue@0.2.0-draft2/store.wit

@@ -0,0 +1,124 @@
+package wasi:keyvalue@0.2.0-draft2;
+
+/// A keyvalue interface that provides eventually consistent key-value operations.
+///
+/// Each of these operations acts on a single key-value pair.
+///
+/// The value in the key-value pair is defined as a `u8` byte array and the intention is that it is
+/// the common denominator for all data types defined by different key-value stores to handle data,
+/// ensuring compatibility between different key-value stores. Note: the clients will be expecting
+/// serialization/deserialization overhead to be handled by the key-value store. The value could be
+/// a serialized object from JSON, HTML or vendor-specific data types like AWS S3 objects.
+///
+/// Data consistency in a key value store refers to the guarantee that once a write operation
+/// completes, all subsequent read operations will return the value that was written.
+///
+/// Any implementation of this interface must have enough consistency to guarantee "reading your
+/// writes." In particular, this means that the client should never get a value that is older than
+/// the one it wrote, but it MAY get a newer value if one was written around the same time. These
+/// guarantees only apply to the same client (which will likely be provided by the host or an
+/// external capability of some kind). In this context a "client" is referring to the caller or
+/// guest that is consuming this interface. Once a write request is committed by a specific client,
+/// all subsequent read requests by the same client will reflect that write or any subsequent
+/// writes. Another client running in a different context may or may not immediately see the result
+/// due to the replication lag. As an example of all of this, if a value at a given key is A, and
+/// the client writes B, then immediately reads, it should get B. If something else writes C in
+/// quick succession, then the client may get C. However, a client running in a separate context may
+/// still see A or B
+interface store {
+  /// The set of errors which may be raised by functions in this package
+  variant error {
+    /// The host does not recognize the store identifier requested.
+    no-such-store,
+
+      /// The requesting component does not have access to the specified store
+      /// (which may or may not exist).
+    access-denied,
+
+      /// Some implementation-specific error has occurred (e.g. I/O)
+    other(string)
+  }
+
+  /// A response to a `list-keys` operation.
+  record key-response {
+    /// The list of keys returned by the query.
+    keys: list<string>,
+      /// The continuation token to use to fetch the next page of keys. If this is `null`, then
+      /// there are no more keys to fetch.
+    cursor: option<string>
+  }
+
+  /// Get the bucket with the specified identifier.
+  ///
+  /// `identifier` must refer to a bucket provided by the host.
+  ///
+  /// `error::no-such-store` will be raised if the `identifier` is not recognized.
+  open: func(identifier: string) -> result<bucket, error>;
+
+  /// A bucket is a collection of key-value pairs. Each key-value pair is stored as a entry in the
+  /// bucket, and the bucket itself acts as a collection of all these entries.
+  ///
+  /// It is worth noting that the exact terminology for bucket in key-value stores can very
+  /// depending on the specific implementation. For example:
+  ///
+  /// 1. Amazon DynamoDB calls a collection of key-value pairs a table
+  /// 2. Redis has hashes, sets, and sorted sets as different types of collections
+  /// 3. Cassandra calls a collection of key-value pairs a column family
+  /// 4. MongoDB calls a collection of key-value pairs a collection
+  /// 5. Riak calls a collection of key-value pairs a bucket
+  /// 6. Memcached calls a collection of key-value pairs a slab
+  /// 7. Azure Cosmos DB calls a collection of key-value pairs a container
+  ///
+  /// In this interface, we use the term `bucket` to refer to a collection of key-value pairs
+  resource bucket {
+    /// Get the value associated with the specified `key`
+    ///
+    /// The value is returned as an option. If the key-value pair exists in the
+    /// store, it returns `Ok(value)`. If the key does not exist in the
+    /// store, it returns `Ok(none)`.
+    ///
+    /// If any other error occurs, it returns an `Err(error)`.
+    get: func(key: string) -> result<option<list<u8>>, error>;
+
+    /// Set the value associated with the key in the store. If the key already
+    /// exists in the store, it overwrites the value.
+    ///
+    /// If the key does not exist in the store, it creates a new key-value pair.
+    ///
+    /// If any other error occurs, it returns an `Err(error)`.
+    set: func(key: string, value: list<u8>) -> result<_, error>;
+
+    /// Delete the key-value pair associated with the key in the store.
+    ///
+    /// If the key does not exist in the store, it does nothing.
+    ///
+    /// If any other error occurs, it returns an `Err(error)`.
+    delete: func(key: string) -> result<_, error>;
+
+    /// Check if the key exists in the store.
+    ///
+    /// If the key exists in the store, it returns `Ok(true)`. If the key does
+    /// not exist in the store, it returns `Ok(false)`.
+    ///
+    /// If any other error occurs, it returns an `Err(error)`.
+    exists: func(key: string) -> result<bool, error>;
+
+    /// Get all the keys in the store with an optional cursor (for use in pagination). It
+    /// returns a list of keys. Please note that for most KeyValue implementations, this is a
+    /// can be a very expensive operation and so it should be used judiciously. Implementations
+    /// can return any number of keys in a single response, but they should never attempt to
+    /// send more data than is reasonable (i.e. on a small edge device, this may only be a few
+    /// KB, while on a large machine this could be several MB). Any response should also return
+    /// a cursor that can be used to fetch the next page of keys. See the `key-response` record
+    /// for more information.
+    ///
+    /// Note that the keys are not guaranteed to be returned in any particular order.
+    ///
+    /// If the store is empty, it returns an empty list.
+    ///
+    /// MAY show an out-of-date list of keys if there are concurrent writes to the store.
+    ///
+    /// If any error occurs, it returns an `Err(error)`.
+    list-keys: func(cursor: option<string>) -> result<key-response, error>;
+  }
+}

package/resources/apps/nextclaw-github-issue-watcher/guest/wit/portable-service.wit

@@ -0,0 +1,56 @@
+package nextclaw:portable-service@0.1.0;
+
+interface host {
+  enum log-level {
+    debug,
+    info,
+    warn,
+    error,
+  }
+
+  record http-response {
+    status: u16,
+    body: string,
+  }
+
+  record runtime-info {
+    runner-pid: u32,
+    loaded-components: u32,
+    component-id: string,
+  }
+
+  log: func(level: log-level, message: string);
+  kv-get: func(key: string) -> result<option<string>, string>;
+  kv-set: func(key: string, value: string) -> result<_, string>;
+  http-get: func(url: string) -> result<http-response, string>;
+  component-call: func(provider-id: string, action: string, input-json: string) -> result<string, string>;
+  get-runtime-info: func() -> runtime-info;
+  /// A job-scoped, bounded observation channel. Older Components that do not
+  /// import these functions remain link-compatible with this host interface.
+  report-progress: func(current: option<u64>, total: option<u64>, message: option<string>) -> result<_, string>;
+  emit-chunk: func(content: string) -> result<_, string>;
+  check-cancelled: func() -> bool;
+}
+
+interface service {
+  record action {
+    name: string,
+    title: string,
+    description: string,
+  }
+
+  list-actions: func() -> list<action>;
+  invoke: func(action: string, input-json: string) -> result<string, string>;
+  start: func(config-json: string) -> result<string, string>;
+  handle-event: func(event-json: string) -> result<string, string>;
+  stop: func(reason-json: string) -> result<string, string>;
+}
+
+world service-app {
+  import host;
+  import wasi:http/outgoing-handler@0.2.6;
+  import wasi:keyvalue/store@0.2.0-draft2;
+  import wasi:config/store@0.2.0-draft-2024-09-27;
+  import wasi:clocks/wall-clock@0.2.6;
+  export service;
+}

package/resources/apps/nextclaw-github-issue-watcher/manifest.json

@@ -0,0 +1,34 @@
+{
+  "schemaVersion": 2,
+  "id": "nextclaw.github-issue-watcher",
+  "name": "GitHub Issue Watcher",
+  "version": "0.1.0",
+  "description": "同步 GitHub 仓库的 Issue，并在 NextClaw 中筛选查看。",
+  "engines": { "nextclaw": ">=0.46.0" },
+  "runtime": { "profile": "wasi" },
+  "distribution": { "mode": "universal" },
+  "storage": { "scope": "global", "schemaVersion": 1 },
+  "presentation": { "primaryPanel": "nextclaw-github-issue-watcher-panel" },
+  "permissions": {
+    "storage": { "namespace": "github-issue-watcher" },
+    "allowedDomains": ["api.github.com"],
+    "secrets": [
+      {
+        "id": "github-token",
+        "title": "GitHub Token（可选）",
+        "description": "用于私有仓库或更高 GitHub API 限额；不会显示给应用或用户界面。",
+        "required": false
+      }
+    ]
+  },
+  "components": [
+    {
+      "kind": "panel",
+      "path": "panels/nextclaw-github-issue-watcher-panel.panel"
+    },
+    {
+      "kind": "service",
+      "path": "service-components/nextclaw-github-issue-watcher-service"
+    }
+  ]
+}

package/resources/apps/nextclaw-github-issue-watcher/marketplace.json

@@ -0,0 +1,18 @@
+{
+  "slug": "github-issue-watcher",
+  "summary": "Sync and review GitHub issues from a portable NextClaw app.",
+  "summaryI18n": {
+    "zh-CN": "在可移植的 NextClaw 应用中同步和查看 GitHub Issue。",
+    "en-US": "Sync and review GitHub issues from a portable NextClaw app."
+  },
+  "description": "A small reference app that uses portable HTTP, local persistent storage, and an optional secret without exposing credentials to the app.",
+  "descriptionI18n": {
+    "zh-CN": "一个真实的参考应用：使用可移植网络访问、本地持久化和可选密钥，并且不会把凭据暴露给应用。",
+    "en-US": "A small reference app that uses portable HTTP, local persistent storage, and an optional secret without exposing credentials to the app."
+  },
+  "author": "NextClaw",
+  "tags": ["github", "issues", "portable", "reference"],
+  "sourceRepo": "https://github.com/Peiiii/nextclaw",
+  "homepage": "https://nextclaw.io",
+  "featured": false
+}