@quantiya/codevibe-claude-plugin 1.0.13 → 1.0.14

package/node_modules/keytar/package.json

@@ -0,0 +1,66 @@
+{
+  "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

@@ -0,0 +1,242 @@
+#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

@@ -0,0 +1,103 @@
+#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

@@ -0,0 +1,13 @@
+#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

@@ -0,0 +1,41 @@
+#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_