opencode-teammate 0.1.0

package/src/utils/shell/client.ts

@@ -0,0 +1,117 @@
+import { type ShellExpression } from "bun";
+import { isArray, isBoolean, isEmpty, isObject, listify, shake, sift, tryit } from "radashi";
+import { InvalidExitCodeError, ShellError } from "./error";
+
+export interface ExecOptions {
+  quiet?: boolean;
+}
+
+export interface Client extends ExecuteTemplateTag {
+  [SHELL_CLIENT]: true;
+
+  // Bun $ extension
+  cwd(path: string): Client;
+  env(vars: Record<string, string>): Client;
+}
+
+export type ClientInput = Client | Bun.$;
+export function use(input: ClientInput): Client {
+  if (input instanceof Bun.$.Shell) return create(input);
+  if (SHELL_CLIENT in input) return input;
+
+  throw new Error("Invalid client input");
+}
+
+export function create(_$: Bun.$): Client {
+  let shell = _$;
+
+  const makeExec: ExecuteTemplateTag = <T>(
+    strings: TemplateStringsArray,
+    ...expressions: (CLIPositionalArgument | CLIOptions)[]
+  ): ShellPromise<T> => {
+    let injected = 0;
+
+    const parts = [...strings];
+    const extended = expressions.flatMap((expr, i): ShellExpression[] => {
+      if (!isObject(expr)) return [expr];
+
+      const options = listify(shake(expr), (key, value) => {
+        if (isBoolean(value)) return `--${key}`;
+        if (isArray(value)) return `--${key}=${sift(value).join(",")}`;
+
+        return `--${key}='${String(value)}'`;
+      });
+
+      if (isEmpty(options)) return [""];
+
+      const separators = options.length - 1;
+
+      parts.splice(i + 1 + injected, 0, ...Array(separators).fill(" "));
+      injected += separators;
+
+      return options;
+    });
+
+    const template = Object.assign(parts, {
+      raw: [...parts],
+    }) as TemplateStringsArray;
+
+    const promise = shell(template, ...extended);
+    return createPromise(promise);
+  };
+
+  const client: Client = Object.assign(makeExec, {
+    [SHELL_CLIENT]: <const>true,
+    cwd(path: string): Client {
+      shell = shell.cwd(path);
+      return client;
+    },
+
+    env(vars: Record<string, string>): Client {
+      shell = shell.env(vars);
+      return client;
+    },
+  });
+
+  return client;
+}
+
+const SHELL_CLIENT = Symbol("shell_client");
+
+type PrimaryType = string | number | boolean | undefined;
+type CLIPositionalArgument = string | number | boolean;
+type CLIOptions = Record<string, PrimaryType | PrimaryType[] | undefined>;
+type CLIExpression = CLIPositionalArgument | CLIOptions | Record<string, any>;
+
+interface ShellPromise<U = unknown> {
+  json: <T = U>(options?: ExecOptions) => Promise<T>;
+  text: (
+    options?: ExecOptions,
+  ) => Promise<[ShellError, string | undefined] | [undefined, string | undefined]>;
+}
+
+function createPromise(shell: Bun.$.ShellPromise): ShellPromise {
+  return {
+    json: async <T = unknown>(options?: ExecOptions) => {
+      const output = await shell.quiet(options?.quiet).nothrow();
+      const [notJson, result] = await tryit(() => output.json())();
+      if (result) return result as T;
+
+      throw new ShellError(output, { cause: notJson });
+    },
+    text: async (options?: ExecOptions) => {
+      const output = await shell.quiet(options?.quiet).nothrow();
+      const out = output.stdout.toString().trim() || undefined;
+
+      if (output.exitCode !== 0)
+        return <const>[new ShellError(output, { cause: new InvalidExitCodeError(output) }), out];
+
+      return <const>[undefined, out];
+    },
+  };
+}
+
+type ExecuteTemplateTag = <T>(
+  strings: TemplateStringsArray,
+  ...expressions: CLIExpression[]
+) => ShellPromise<T>;

package/src/utils/shell/error.ts

@@ -0,0 +1,29 @@
+export class ShellError extends Error {
+  private readonly output: Bun.$.ShellOutput;
+
+  constructor(
+    output: Bun.$.ShellOutput,
+    options: {
+      cause?: Error;
+    },
+  ) {
+    const stdout = output.stdout.toString().trim() || undefined;
+    const stderr = output.stderr.toString().trim() || undefined;
+    const message = stderr ?? stdout ?? "Unknown shell error";
+
+    super(message, { cause: options.cause });
+
+    this.output = output;
+  }
+}
+
+export class InvalidExitCodeError extends Error {
+  public readonly exitCode: number;
+
+  constructor(output: Bun.$.ShellOutput) {
+    const exitCode = output.exitCode;
+    super(`Exited with code '${exitCode}'`);
+
+    this.exitCode = exitCode;
+  }
+}

package/src/utils/shell/index.ts

@@ -0,0 +1,2 @@
+export * as client from "./client";
+export { ShellError } from "./error";

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://www.schemastore.org/tsconfig",
+  "extends": "@tsconfig/bun/tsconfig.json",
+  "compilerOptions": {
+    "moduleResolution": "bundler",
+    "resolvePackageJsonImports": true,
+    "resolvePackageJsonExports": true
+  }
+}