@quantiya/codevibe-claude-plugin 1.0.11 → 1.0.13

package/node_modules/keytar/package.json

@@ -1,66 +0,0 @@
-{
-  "main": "./lib/keytar.js",
-  "typings": "keytar.d.ts",
-  "name": "keytar",
-  "description": "Bindings to native Mac/Linux/Windows password APIs",
-  "version": "7.9.0",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/atom/node-keytar.git"
-  },
-  "bugs": {
-    "url": "https://github.com/atom/node-keytar/issues"
-  },
-  "homepage": "http://atom.github.io/node-keytar",
-  "keywords": [
-    "keychain",
-    "password",
-    "passwords",
-    "credential",
-    "credentials",
-    "vault",
-    "credential vault"
-  ],
-  "files": [
-    "lib",
-    "src",
-    "binding.gyp",
-    "keytar.d.ts"
-  ],
-  "types": "./keytar.d.ts",
-  "scripts": {
-    "install": "prebuild-install || npm run build",
-    "build": "node-gyp rebuild",
-    "lint": "npm run cpplint",
-    "cpplint": "node-cpplint --filters legal-copyright,build-include,build-namespaces src/*.cc",
-    "test": "npm run lint && npm rebuild && mocha --require babel-core/register spec/",
-    "prebuild-napi-x64": "prebuild -t 3 -r napi -a x64 --strip",
-    "prebuild-napi-ia32": "prebuild -t 3 -r napi -a ia32 --strip",
-    "prebuild-napi-arm64": "prebuild -t 3 -r napi -a arm64 --strip",
-    "prebuild-napi-armv7l": "prebuild -t 3 -r napi -a armv7l --strip",
-    "upload": "node ./script/upload.js"
-  },
-  "devDependencies": {
-    "babel-core": "^6.26.3",
-    "babel-plugin-transform-async-to-generator": "^6.24.1",
-    "chai": "^4.2.0",
-    "mocha": "^9.2.0",
-    "node-cpplint": "~0.4.0",
-    "node-gyp": "^8.4.1",
-    "prebuild": "^11.0.2"
-  },
-  "dependencies": {
-    "node-addon-api": "^4.3.0",
-    "prebuild-install": "^7.0.1"
-  },
-  "binary": {
-    "napi_versions": [
-      3
-    ]
-  },
-  "config": {
-    "runtime": "napi",
-    "target": 3
-  }
-}

package/node_modules/keytar/src/async.cc

@@ -1,242 +0,0 @@
-#include <string>
-#include <vector>
-
-#include "napi.h"
-#include "keytar.h"
-#include "async.h"
-
-using keytar::KEYTAR_OP_RESULT;
-
-SetPasswordWorker::SetPasswordWorker(
-  const std::string& service,
-  const std::string& account,
-  const std::string& password,
-  const Napi::Env &env
-) : AsyncWorker(env),
-    service(service),
-    account(account),
-    password(password),
-    deferred(Napi::Promise::Deferred::New(env)) {}
-
-SetPasswordWorker::~SetPasswordWorker() {}
-
-Napi::Promise SetPasswordWorker::Promise() {
-  return deferred.Promise();
-}
-
-void SetPasswordWorker::Execute() {
-  std::string error;
-  KEYTAR_OP_RESULT result = keytar::SetPassword(service,
-                                                account,
-                                                password,
-                                                &error);
-  if (result == keytar::FAIL_ERROR) {
-    SetError(error.c_str());
-  }
-}
-
-void SetPasswordWorker::OnOK() {
-  Napi::HandleScope scope(Env());
-  deferred.Resolve(Env().Undefined());
-}
-
-void SetPasswordWorker::OnError(Napi::Error const &error) {
-  Napi::HandleScope scope(Env());
-  deferred.Reject(error.Value());
-}
-
-
-GetPasswordWorker::GetPasswordWorker(
-  const std::string& service,
-  const std::string& account,
-  const Napi::Env &env
-) : AsyncWorker(env),
-    service(service),
-    account(account),
-    deferred(Napi::Promise::Deferred::New(env)) {}
-
-GetPasswordWorker::~GetPasswordWorker() {}
-
-Napi::Promise GetPasswordWorker::Promise() {
-  return deferred.Promise();
-}
-
-void GetPasswordWorker::Execute() {
-  std::string error;
-  KEYTAR_OP_RESULT result = keytar::GetPassword(service,
-                                                account,
-                                                &password,
-                                                &error);
-  if (result == keytar::FAIL_ERROR) {
-    SetError(error.c_str());
-  } else if (result == keytar::FAIL_NONFATAL) {
-    success = false;
-  } else {
-    success = true;
-  }
-}
-
-void GetPasswordWorker::OnOK() {
-  Napi::HandleScope scope(Env());
-  Napi::Value val = Env().Null();
-  if (success) {
-    val = Napi::String::New(Env(), password.data(),
-                               password.length());
-  }
-  deferred.Resolve(val);
-}
-
-void GetPasswordWorker::OnError(Napi::Error const &error) {
-  Napi::HandleScope scope(Env());
-  deferred.Reject(error.Value());
-}
-
-DeletePasswordWorker::DeletePasswordWorker(
-  const std::string& service,
-  const std::string& account,
-  const Napi::Env &env
-) : AsyncWorker(env),
-    service(service),
-    account(account),
-    deferred(Napi::Promise::Deferred::New(env)) {}
-
-DeletePasswordWorker::~DeletePasswordWorker() {}
-
-Napi::Promise DeletePasswordWorker::Promise() {
-  return deferred.Promise();
-}
-
-void DeletePasswordWorker::Execute() {
-  std::string error;
-  KEYTAR_OP_RESULT result = keytar::DeletePassword(service, account, &error);
-  if (result == keytar::FAIL_ERROR) {
-    SetError(error.c_str());
-  } else if (result == keytar::FAIL_NONFATAL) {
-    success = false;
-  } else {
-    success = true;
-  }
-}
-
-void DeletePasswordWorker::OnOK() {
-  Napi::HandleScope scope(Env());
-  deferred.Resolve(Napi::Boolean::New(Env(), success));
-}
-
-void DeletePasswordWorker::OnError(Napi::Error const &error) {
-  Napi::HandleScope scope(Env());
-  deferred.Reject(error.Value());
-}
-
-FindPasswordWorker::FindPasswordWorker(
-  const std::string& service,
-  const Napi::Env &env
-) : AsyncWorker(env),
-    service(service),
-    deferred(Napi::Promise::Deferred::New(env)) {}
-
-FindPasswordWorker::~FindPasswordWorker() {}
-
-Napi::Promise FindPasswordWorker::Promise() {
-  return deferred.Promise();
-}
-
-void FindPasswordWorker::Execute() {
-  std::string error;
-  KEYTAR_OP_RESULT result = keytar::FindPassword(service,
-                                                 &password,
-                                                 &error);
-  if (result == keytar::FAIL_ERROR) {
-    SetError(error.c_str());
-  } else if (result == keytar::FAIL_NONFATAL) {
-    success = false;
-  } else {
-    success = true;
-  }
-}
-
-void FindPasswordWorker::OnOK() {
-  Napi::HandleScope scope(Env());
-  Napi::Value val = Env().Null();
-  if (success) {
-    val = Napi::String::New(Env(), password.data(),
-                               password.length());
-  }
-  deferred.Resolve(val);
-}
-
-void FindPasswordWorker::OnError(Napi::Error const &error) {
-  Napi::HandleScope scope(Env());
-  deferred.Reject(error.Value());
-}
-
-FindCredentialsWorker::FindCredentialsWorker(
-  const std::string& service,
-  const Napi::Env &env
-) : AsyncWorker(env),
-    service(service),
-    deferred(Napi::Promise::Deferred::New(env)) {}
-
-FindCredentialsWorker::~FindCredentialsWorker() {}
-
-Napi::Promise FindCredentialsWorker::Promise() {
-  return deferred.Promise();
-}
-
-void FindCredentialsWorker::Execute() {
-  std::string error;
-  KEYTAR_OP_RESULT result = keytar::FindCredentials(service,
-                                                    &credentials,
-                                                    &error);
-  if (result == keytar::FAIL_ERROR) {
-    SetError(error.c_str());
-  } else if (result == keytar::FAIL_NONFATAL) {
-    success = false;
-  } else {
-    success = true;
-  }
-}
-
-void FindCredentialsWorker::OnOK() {
-  Napi::HandleScope scope(Env());
-  Napi::Env env = Env();
-
-  if (success) {
-    Napi::Array val = Napi::Array::New(env, credentials.size());
-    unsigned int idx = 0;
-    std::vector<keytar::Credentials>::iterator it;
-    for (it = credentials.begin(); it != credentials.end(); it++) {
-      keytar::Credentials cred = *it;
-      Napi::Object obj = Napi::Object::New(env);
-
-      Napi::String account = Napi::String::New(env,
-        cred.first.data(),
-        cred.first.length());
-
-      Napi::String password = Napi::String::New(env,
-        cred.second.data(),
-        cred.second.length());
-
-#ifndef _WIN32
-#pragma GCC diagnostic ignored "-Wunused-result"
-#endif
-      obj.Set("account", account);
-#ifndef _WIN32
-#pragma GCC diagnostic ignored "-Wunused-result"
-#endif
-      obj.Set("password", password);
-
-      (val).Set(idx, obj);
-      ++idx;
-    }
-
-    deferred.Resolve(val);
-  } else {
-    deferred.Resolve(Napi::Array::New(env, 0));
-  }
-}
-
-void FindCredentialsWorker::OnError(Napi::Error const &error) {
-  Napi::HandleScope scope(Env());
-  deferred.Reject(error.Value());
-}

package/node_modules/keytar/src/async.h

@@ -1,103 +0,0 @@
-#ifndef SRC_ASYNC_H_
-#define SRC_ASYNC_H_
-
-#include <string>
-#include "napi.h"
-
-#include "credentials.h"
-
-class SetPasswordWorker : public Napi::AsyncWorker {
-  public:
-    SetPasswordWorker(const std::string& service, const std::string& account, const std::string& password,
-                      const Napi::Env &env);
-
-    ~SetPasswordWorker();
-
-    void Execute();
-    void OnOK();
-    void OnError(Napi::Error const &error);
-    Napi::Promise Promise();
-
-  private:
-    const std::string service;
-    const std::string account;
-    const std::string password;
-    Napi::Promise::Deferred deferred;
-};
-
-class GetPasswordWorker : public Napi::AsyncWorker {
-  public:
-    GetPasswordWorker(const std::string& service, const std::string& account,
-                      const Napi::Env &env);
-
-    ~GetPasswordWorker();
-
-    void Execute();
-    void OnOK();
-    void OnError(Napi::Error const &error);
-    Napi::Promise Promise();
-
-  private:
-    const std::string service;
-    const std::string account;
-    std::string password;
-    bool success;
-    const Napi::Promise::Deferred deferred;
-};
-
-class DeletePasswordWorker : public Napi::AsyncWorker {
-  public:
-    DeletePasswordWorker(const std::string& service, const std::string& account,
-                         const Napi::Env &env);
-
-    ~DeletePasswordWorker();
-
-    void Execute();
-    void OnOK();
-    void OnError(Napi::Error const &error);
-    Napi::Promise Promise();
-
-  private:
-    const std::string service;
-    const std::string account;
-    bool success;
-    Napi::Promise::Deferred deferred;
-};
-
-class FindPasswordWorker : public Napi::AsyncWorker {
-  public:
-    FindPasswordWorker(const std::string& service, const Napi::Env &env);
-
-    ~FindPasswordWorker();
-
-    void Execute();
-    void OnOK();
-    void OnError(Napi::Error const &error);
-    Napi::Promise Promise();
-
-  private:
-    const std::string service;
-    std::string password;
-    bool success;
-    const Napi::Promise::Deferred deferred;
-};
-
-class FindCredentialsWorker : public Napi::AsyncWorker {
-  public:
-    FindCredentialsWorker(const std::string& service, const Napi::Env &env);
-
-    ~FindCredentialsWorker();
-
-    void Execute();
-    void OnOK();
-    void OnError(Napi::Error const &error);
-    Napi::Promise Promise();
-
-  private:
-    const std::string service;
-    std::vector<keytar::Credentials> credentials;
-    bool success;
-    const Napi::Promise::Deferred deferred;
-};
-
-#endif  // SRC_ASYNC_H_

package/node_modules/keytar/src/credentials.h

@@ -1,13 +0,0 @@
-#ifndef SRC_CREDENTIALS_H_
-#define SRC_CREDENTIALS_H_
-
-#include <string>
-#include <utility>
-
-namespace keytar {
-
-typedef std::pair<std::string, std::string> Credentials;
-
-}
-
-#endif  // SRC_CREDENTIALS_H_

package/node_modules/keytar/src/keytar.h

@@ -1,41 +0,0 @@
-#ifndef SRC_KEYTAR_H_
-#define SRC_KEYTAR_H_
-
-#include <string>
-#include <vector>
-
-#include "credentials.h"
-
-namespace keytar {
-
-enum KEYTAR_OP_RESULT {
-  SUCCESS,
-  FAIL_ERROR,
-  FAIL_NONFATAL
-};
-
-KEYTAR_OP_RESULT SetPassword(const std::string& service,
-                             const std::string& account,
-                             const std::string& password,
-                             std::string* error);
-
-KEYTAR_OP_RESULT GetPassword(const std::string& service,
-                             const std::string& account,
-                             std::string* password,
-                             std::string* error);
-
-KEYTAR_OP_RESULT DeletePassword(const std::string& service,
-                                const std::string& account,
-                                std::string* error);
-
-KEYTAR_OP_RESULT FindPassword(const std::string& service,
-                              std::string* password,
-                              std::string* error);
-
-KEYTAR_OP_RESULT FindCredentials(const std::string& service,
-                                 std::vector<Credentials>*,
-                                 std::string* error);
-
-}  // namespace keytar
-
-#endif  // SRC_KEYTAR_H_