@highstate/common 0.4.4 → 0.4.6

package/dist/existing-server/index.js

@@ -1,6 +1,9 @@
 import { common } from '@highstate/library';
 import { forUnit, output } from '@highstate/pulumi';
 import { remote } from '@pulumi/command';
+import '@noble/hashes/utils';
+import 'micro-key-producer/password.js';
+import { c as createSshTerminal } from '../ssh-XS5DEPfW.js';
 
 const { args, secrets, outputs } = forUnit(common.existingServer);
 const hostnameResult = new remote.Command("hostname", {
@@ -15,40 +18,24 @@ const hostnameResult = new remote.Command("hostname", {
   triggers: [Date.now()]
 });
 const hostname = hostnameResult.stdout.apply((x) => x.trim());
-const port = args.sshPort ?? 22;
-const user = args.sshUser ?? "root";
+const sshCredentials = output({
+  user: args.sshUser,
+  port: args.sshPort,
+  password: secrets.sshPassword
+});
 var index = outputs({
   server: {
     endpoint: args.endpoint,
     hostname,
-    sshCredentials: {
-      user: args.sshUser,
-      port: args.sshPort,
-      password: secrets.sshPassword
-    }
+    sshCredentials
   },
   $status: {
     hostname: {
       value: hostname
     }
   },
-  $terminal: {
-    image: "ghcr.io/exeteres/highstate/terminal-ssh",
-    command: [
-      "sshpass",
-      "-f",
-      "/password",
-      "ssh",
-      "-tt",
-      "-o",
-      "StrictHostKeyChecking=no",
-      "-p",
-      port.toString(),
-      `${user}@${args.endpoint}`
-    ],
-    files: {
-      "/password": secrets.sshPassword?.apply((x) => x ?? "") ?? ""
-    }
+  $terminals: {
+    ssh: sshCredentials.apply((credentials) => createSshTerminal(credentials, args.endpoint))
   }
 });
 

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { types, remote } from '@pulumi/command';
-import { Input, Output, InputOrArray, Resource } from '@highstate/pulumi';
-import { common } from '@highstate/library';
+import { Input, Output, InputOrArray, Resource, ComponentResource, ResourceOptions, Unwrap, InstanceTerminal } from '@highstate/pulumi';
+import { common, ssh } from '@highstate/library';
 
 declare function getServerConnection(server: Input<common.Server>): Output<types.input.remote.ConnectionArgs>;
 interface CommandOptions {
@@ -19,4 +19,44 @@ declare class Server {
     command(options: CommandOptions): remote.Command;
 }
 
-export { type CommandOptions, Server, getServerConnection };
+type DnsRecordArgs = {
+    /**
+     * The DNS provider to use.
+     */
+    provider: Input<common.DnsProvider>;
+    /**
+     * The name of the DNS record.
+     * If not provided, the name of the resource will be used.
+     */
+    name?: Input<string>;
+    /**
+     * The type of the DNS record.
+     */
+    type: Input<string>;
+    /**
+     * The value of the DNS record.
+     */
+    value: Input<string>;
+    /**
+     * Whether the DNS record is proxied (e.g. to provide DDoS protection).
+     *
+     * Available only for public IPs and some DNS providers like Cloudflare.
+     * If not supported, the DNS provider will ignore this value.
+     */
+    proxied?: Input<boolean>;
+};
+declare abstract class DnsRecord extends ComponentResource {
+    /**
+     * The underlying dns record resource.
+     */
+    readonly dnsRecord: Output<Resource>;
+    constructor(name: string, args: DnsRecordArgs, opts?: ResourceOptions);
+    protected abstract create(name: string, args: Unwrap<DnsRecordArgs>, opts?: ResourceOptions): Input<Resource>;
+    static create(name: string, args: DnsRecordArgs, opts?: ResourceOptions): Output<DnsRecord>;
+}
+
+declare function generatePassword(): string;
+
+declare function createSshTerminal(credentials: ssh.Credentials, fallbackEndpoint: string): InstanceTerminal;
+
+export { type CommandOptions, DnsRecord, type DnsRecordArgs, Server, createSshTerminal, generatePassword, getServerConnection };

package/dist/index.js

@@ -1,6 +1,9 @@
 import { remote } from '@pulumi/command';
-import { output } from '@highstate/pulumi';
+import { output, ComponentResource } from '@highstate/pulumi';
 import '@highstate/library';
+import { randomBytes } from '@noble/hashes/utils';
+import { secureMask } from 'micro-key-producer/password.js';
+export { c as createSshTerminal } from './ssh-XS5DEPfW.js';
 
 function getServerConnection(server) {
   return output(server).apply((server2) => ({
@@ -8,6 +11,7 @@ function getServerConnection(server) {
     port: server2.sshCredentials?.port ?? 22,
     user: server2.sshCredentials?.user ?? "root",
     password: server2.sshCredentials?.password,
+    privateKey: server2.sshCredentials?.keyPair?.privateKey,
     dialErrorLimit: 3
   }));
 }
@@ -38,4 +42,48 @@ class Server {
   }
 }
 
-export { Server, getServerConnection };
+function u$1(o, n, a) {
+  let t = (r) => o(r, ...n);
+  return a === void 0 ? t : Object.assign(t, { lazy: a, lazyArgs: n });
+}
+
+function u(r, n, o) {
+  let a = r.length - n.length;
+  if (a === 0) return r(...n);
+  if (a === 1) return u$1(r, n, o);
+  throw new Error("Wrong number of arguments");
+}
+
+function n(...t) {
+  return u(e, t);
+}
+var e = (t) => `${t[0]?.toUpperCase() ?? ""}${t.slice(1)}`;
+
+class DnsRecord extends ComponentResource {
+  /**
+   * The underlying dns record resource.
+   */
+  dnsRecord;
+  constructor(name, args, opts) {
+    super("highstate:common:DnsRecord", name, args, opts);
+    this.dnsRecord = output(args).apply((args2) => {
+      return output(this.create(name, args2, { ...opts, parent: this }));
+    });
+    this.registerOutputs({ dnsRecord: this.dnsRecord });
+  }
+  static create(name, args, opts) {
+    return output(args).apply(async (args2) => {
+      const providerType = args2.provider.type;
+      const implName = `${n(providerType)}DnsRecord`;
+      const implModule = await import(`@highstate/${providerType}`);
+      const implClass = implModule[implName];
+      return new implClass(name, args2, opts);
+    });
+  }
+}
+
+function generatePassword() {
+  return secureMask.apply(randomBytes(32)).password;
+}
+
+export { DnsRecord, Server, generatePassword, getServerConnection };

package/dist/ssh-XS5DEPfW.js

@@ -0,0 +1,28 @@
+function createSshTerminal(credentials, fallbackEndpoint) {
+  const command = ["ssh", "-tt", "-o", "StrictHostKeyChecking=no"];
+  if (credentials.port) {
+    command.push("-p", credentials.port.toString());
+  }
+  if (credentials.keyPair) {
+    command.push("-i", "/private-key");
+  }
+  const endpoint = credentials.endpoint ?? fallbackEndpoint;
+  const user = credentials.user ?? "root";
+  command.push(`${user}@${endpoint}`);
+  if (credentials.password) {
+    command.unshift("sshpass", "-f", "/password");
+  }
+  return {
+    name: "ssh",
+    title: "SSH",
+    description: "Connect to the server via SSH.",
+    image: "ghcr.io/exeteres/highstate/terminal-ssh",
+    command,
+    files: {
+      "/password": credentials.password,
+      "/private-key": credentials.keyPair?.privateKey
+    }
+  };
+}
+
+export { createSshTerminal as c };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/common",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "type": "module",
   "files": [
     "dist"
@@ -22,15 +22,16 @@
     "build": "pkgroll --tsconfig=tsconfig.build.json"
   },
   "dependencies": {
-    "@highstate/pulumi": "^0.4.4",
-    "@pulumi/command": "^1.0.1",
+    "@highstate/pulumi": "^0.4.6",
+    "@noble/hashes": "^1.7.1",
+    "@pulumi/command": "^1.0.2",
     "micro-key-producer": "^0.7.3"
   },
   "peerDependencies": {
-    "@highstate/library": "workspace:^"
+    "@highstate/library": "workspace:^0.4.4"
   },
   "devDependencies": {
     "pkgroll": "^2.5.1"
   },
-  "gitHead": "58a1b969cca5dad233f885f2e67185a0384ea1aa"
+  "gitHead": "dbb1d8125884cfe3a9d95df2e0710333c01c7edf"
 }