@amerged/ohmyhost-cli 0.1.10

package/dist/credential-store.js

@@ -0,0 +1,15 @@
+import { createRequire as __ohmyhostCreateRequire } from "node:module"; const require = __ohmyhostCreateRequire(import.meta.url);
+import {
+  CredentialStoreIntegrityError,
+  CredentialStoreUnavailableError,
+  NativeNapiKeyringCredentialStore,
+  parseCredential,
+  serializeCredential
+} from "./chunk-4HFQ54FP.js";
+export {
+  CredentialStoreIntegrityError,
+  CredentialStoreUnavailableError,
+  NativeNapiKeyringCredentialStore,
+  parseCredential,
+  serializeCredential
+};

package/dist/index.js

@@ -0,0 +1,249 @@
+import { createRequire as __ohmyhostCreateRequire } from "node:module"; const require = __ohmyhostCreateRequire(import.meta.url);
+import {
+  GeneratedSdkProductApi,
+  GeneratedSdkSessionRevoker,
+  InteractiveSessionRequiredError,
+  InvalidCommandError,
+  LifecycleTransportError,
+  NetworkTransportError,
+  OwnerOnlyProjectLinkStore,
+  ProductApiAuthenticationError,
+  ProductCli,
+  ProviderCapabilityBlockedError,
+  PsqlUnavailableError,
+  PublicResponseTooLargeError,
+  PublicWorkosTokenRefresher,
+  RepositoryInitBlockedError,
+  RepositoryInitConflictError,
+  RepositoryInitError,
+  SecretInputError,
+  StderrDeviceAuthorizationPresenter,
+  TokenRefreshRejectedError,
+  UserTokenFileError,
+  chooseWorkspace,
+  cliMetadataResult,
+  createAuthenticatedProductTransport,
+  createBoundedFetch,
+  createProductionAuthenticatedProductApi,
+  initializeRepository,
+  parseAccountProfile,
+  parseCloudflareDnsAuthorization,
+  parseCloudflareDnsAuthorizationStatus,
+  parseCurrentIdentity,
+  parseDevAccessTicket,
+  parseOperation,
+  parseOperationEvent,
+  parsePaidDomain,
+  parsePaidDomainPlan,
+  parseProductCliCommand,
+  parseSafeProblem,
+  prepareUserTokenFile,
+  publicWorkspace,
+  readBoundedResponseBody,
+  readSecretValueFromStandardInput,
+  recognizedCommandLabel,
+  resolveProductCliEnvironment,
+  runProductionCli,
+  selectWorkspace,
+  selectedWorkspaceId,
+  workspaceOf
+} from "./chunk-Z75ASLEB.js";
+import {
+  CredentialStoreIntegrityError,
+  CredentialStoreUnavailableError,
+  NativeNapiKeyringCredentialStore,
+  parseCredential,
+  serializeCredential
+} from "./chunk-4HFQ54FP.js";
+
+// apps/product-cli/dist/file-credential-store.js
+import { constants, lstat, mkdir, open, rename, unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var DIRECTORY_MODE = 448;
+var FILE_MODE = 384;
+var OwnerOnlyFileCredentialStore = class {
+  directory;
+  ownerId;
+  #credentialPath;
+  #temporaryPath;
+  constructor(directory, ownerId) {
+    this.directory = directory;
+    this.ownerId = ownerId;
+    this.#credentialPath = join(directory, "credentials.json");
+    this.#temporaryPath = join(directory, ".credentials.next");
+  }
+  async read() {
+    try {
+      await this.ensureDirectory();
+      await this.recoverTemporary();
+      if (!await this.validateFile())
+        return void 0;
+      const handle = await open(this.#credentialPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+      try {
+        const status = await handle.stat();
+        this.assertOwnedStatus(status, FILE_MODE, false);
+        return parseCredential(await handle.readFile("utf8"));
+      } finally {
+        await handle.close();
+      }
+    } catch {
+      throw new CredentialStoreUnavailableError();
+    }
+  }
+  async replace(credential) {
+    try {
+      await this.ensureDirectory();
+      await this.recoverTemporary();
+      await this.validateFile();
+      const handle = await open(this.#temporaryPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, FILE_MODE);
+      try {
+        await handle.writeFile(serializeCredential(credential), "utf8");
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await this.validateOwnedPath(this.#temporaryPath, FILE_MODE, false);
+      await rename(this.#temporaryPath, this.#credentialPath);
+      await this.syncDirectory();
+      await this.validateOwnedPath(this.#credentialPath, FILE_MODE, false);
+    } catch {
+      await unlink(this.#temporaryPath).catch(() => void 0);
+      throw new CredentialStoreUnavailableError();
+    }
+  }
+  async clear() {
+    try {
+      await this.ensureDirectory();
+      let failed = false;
+      for (const path of [this.#credentialPath, this.#temporaryPath]) {
+        try {
+          await unlink(path);
+        } catch (error) {
+          if (!isMissing(error))
+            failed = true;
+        }
+      }
+      try {
+        await this.syncDirectory();
+      } catch {
+        failed = true;
+      }
+      for (const path of [this.#credentialPath, this.#temporaryPath]) {
+        try {
+          await lstat(path);
+          failed = true;
+        } catch (error) {
+          if (!isMissing(error))
+            failed = true;
+        }
+      }
+      if (failed)
+        throw new Error("Credential artifact cleanup failed");
+    } catch {
+      throw new CredentialStoreUnavailableError();
+    }
+  }
+  async ensureDirectory() {
+    await mkdir(this.directory, { mode: DIRECTORY_MODE, recursive: true });
+    await this.validateOwnedPath(this.directory, DIRECTORY_MODE, true);
+  }
+  async recoverTemporary() {
+    try {
+      const status = await lstat(this.#temporaryPath);
+      const invalid = status.isSymbolicLink() || !status.isFile() || status.uid !== this.ownerId || (status.mode & 511) !== FILE_MODE;
+      await unlink(this.#temporaryPath);
+      await this.syncDirectory();
+      if (invalid)
+        throw new Error("Temporary credential artifact was invalid");
+    } catch (error) {
+      if (!isMissing(error))
+        throw error;
+    }
+  }
+  async validateFile() {
+    try {
+      await this.validateOwnedPath(this.#credentialPath, FILE_MODE, false);
+      return true;
+    } catch (error) {
+      if (isMissing(error))
+        return false;
+      throw error;
+    }
+  }
+  async validateOwnedPath(path, mode, directory) {
+    const status = await lstat(path);
+    if (status.isSymbolicLink()) {
+      throw new Error("Credential path ownership or mode is invalid");
+    }
+    this.assertOwnedStatus(status, mode, directory);
+  }
+  assertOwnedStatus(status, mode, directory) {
+    if ((directory ? !status.isDirectory() : !status.isFile()) || status.uid !== this.ownerId || (Number(status.mode) & 511) !== mode) {
+      throw new Error("Credential path ownership or mode is invalid");
+    }
+  }
+  async syncDirectory() {
+    const handle = await open(dirname(this.#credentialPath), constants.O_RDONLY);
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  }
+};
+var isMissing = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+export {
+  CredentialStoreIntegrityError,
+  CredentialStoreUnavailableError,
+  GeneratedSdkProductApi,
+  GeneratedSdkSessionRevoker,
+  InteractiveSessionRequiredError,
+  InvalidCommandError,
+  LifecycleTransportError,
+  NativeNapiKeyringCredentialStore,
+  NetworkTransportError,
+  OwnerOnlyFileCredentialStore,
+  OwnerOnlyProjectLinkStore,
+  ProductApiAuthenticationError,
+  ProductCli,
+  ProviderCapabilityBlockedError,
+  PsqlUnavailableError,
+  PublicResponseTooLargeError,
+  PublicWorkosTokenRefresher,
+  RepositoryInitBlockedError,
+  RepositoryInitConflictError,
+  RepositoryInitError,
+  SecretInputError,
+  StderrDeviceAuthorizationPresenter,
+  TokenRefreshRejectedError,
+  UserTokenFileError,
+  chooseWorkspace,
+  cliMetadataResult,
+  createAuthenticatedProductTransport,
+  createBoundedFetch,
+  createProductionAuthenticatedProductApi,
+  initializeRepository,
+  parseAccountProfile,
+  parseCloudflareDnsAuthorization,
+  parseCloudflareDnsAuthorizationStatus,
+  parseCredential,
+  parseCurrentIdentity,
+  parseDevAccessTicket,
+  parseOperation,
+  parseOperationEvent,
+  parsePaidDomain,
+  parsePaidDomainPlan,
+  parseProductCliCommand,
+  parseSafeProblem,
+  prepareUserTokenFile,
+  publicWorkspace,
+  readBoundedResponseBody,
+  readSecretValueFromStandardInput,
+  recognizedCommandLabel,
+  resolveProductCliEnvironment,
+  runProductionCli,
+  selectWorkspace,
+  selectedWorkspaceId,
+  serializeCredential,
+  workspaceOf
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@amerged/ohmyhost-cli",
+  "version": "0.1.10",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "src",
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "bin": {
+    "ohmyhost": "./dist/bin.js"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./credential-store": "./dist/credential-store.js"
+  },
+  "dependencies": {
+    "@napi-rs/keyring": "1.3.0"
+  },
+  "license": "Apache-2.0",
+  "homepage": "https://docs.ohmyho.st/",
+  "description": "ohmyho.st cli client",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/apps/product-cli/bin.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+import { runProductionCli } from "./composition.js";
+
+const controller = new AbortController();
+process.once("SIGINT", () => controller.abort(new DOMException("Cancelled", "AbortError")));
+process.once("SIGTERM", () => controller.abort(new DOMException("Cancelled", "AbortError")));
+
+process.exitCode = await runProductionCli(
+  process.argv.slice(2),
+  {
+    ...(process.env["OHMYHOST_ENVIRONMENT"] === undefined
+      ? {}
+      : { OHMYHOST_ENVIRONMENT: process.env["OHMYHOST_ENVIRONMENT"] }),
+    ...(process.env["OHMYHOST_TOKEN"] === undefined
+      ? {}
+      : { OHMYHOST_TOKEN: process.env["OHMYHOST_TOKEN"] }),
+  },
+  {
+    writeStdout: (value) => process.stdout.write(value),
+    writeStderr: (value) => process.stderr.write(value),
+  },
+  controller.signal,
+);