@indigoai-us/hq-cli 5.8.5 → 5.9.0

package/src/run/varlock-shape.test.ts

@@ -0,0 +1,57 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { internal } from 'varlock';
+// Resolver is a type-only export in varlock@1.0.0's plugin-lib.js (d.ts/JS mismatch);
+// the value is extracted at runtime from graph.registeredResolverFunctions below.
+import type { Resolver } from 'varlock/plugin-lib';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let RuntimeResolver: typeof Resolver;
+
+beforeAll(async () => {
+  // Spin up a minimal graph to access built-in resolvers registered by varlock.
+  // No schema files are needed — varlock registers built-in resolvers in afterInit.
+  await internal.loadEnvGraph({
+    entryFilePaths: [],
+    afterInit: async (graph) => {
+      const fns = (graph as any).registeredResolverFunctions as Record<string, unknown>;
+      const firstClass = Object.values(fns)[0];
+      if (firstClass == null) throw new Error('registeredResolverFunctions is empty — varlock API shape changed');
+      // Each registered class extends Resolver; its prototype chain gives us the base class.
+      RuntimeResolver = Object.getPrototypeOf(firstClass) as typeof Resolver;
+    },
+  });
+});
+
+describe('varlock 1.0.0 API shape smoke test', () => {
+  it('internal.loadEnvGraph is a function', () => {
+    expect(typeof internal.loadEnvGraph).toBe('function');
+  });
+
+  it('internal.EnvGraph is a function (class)', () => {
+    expect(typeof internal.EnvGraph).toBe('function');
+  });
+
+  it('EnvGraph.prototype.registerRootDecorator exists', () => {
+    expect(typeof internal.EnvGraph.prototype.registerRootDecorator).toBe('function');
+  });
+
+  it('EnvGraph.prototype.registerResolver exists', () => {
+    expect(typeof internal.EnvGraph.prototype.registerResolver).toBe('function');
+  });
+
+  it('EnvGraph.prototype.registerItemDecorator exists', () => {
+    expect(typeof internal.EnvGraph.prototype.registerItemDecorator).toBe('function');
+  });
+
+  it('EnvGraph.prototype.registerDataType exists', () => {
+    expect(typeof internal.EnvGraph.prototype.registerDataType).toBe('function');
+  });
+
+  it('Resolver.prototype.process exists', () => {
+    expect(typeof RuntimeResolver.prototype.process).toBe('function');
+  });
+
+  it('Resolver.prototype.resolve exists', () => {
+    expect(typeof RuntimeResolver.prototype.resolve).toBe('function');
+  });
+});

package/src/utils/vault-api.ts

@@ -0,0 +1,80 @@
+import { DEFAULT_VAULT_API_URL } from './cognito-session.js';
+
+export interface VaultApiOptions {
+  token: string;
+  path: string;
+  method?: string;
+  body?: Record<string, unknown>;
+  query?: Record<string, string>;
+}
+
+export async function vaultApiFetch(opts: VaultApiOptions): Promise<Response> {
+  const url = new URL(opts.path, DEFAULT_VAULT_API_URL);
+  if (opts.query) {
+    for (const [k, v] of Object.entries(opts.query)) {
+      url.searchParams.set(k, v);
+    }
+  }
+  return fetch(url.toString(), {
+    method: opts.method ?? 'GET',
+    headers: {
+      Authorization: `Bearer ${opts.token}`,
+      'Content-Type': 'application/json',
+    },
+    body: opts.body ? JSON.stringify(opts.body) : undefined,
+  });
+}
+
+interface MembershipEntry {
+  companyUid: string;
+  role: string;
+  status: string;
+  membershipKey: string;
+}
+
+async function resolveCompanyUid(token: string, slug: string): Promise<string> {
+  const res = await vaultApiFetch({
+    token,
+    path: `/entity/by-slug/company/${encodeURIComponent(slug)}`,
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(
+      `Failed to resolve company slug '${slug}': ${(body as Record<string, string>).error ?? res.statusText}`,
+    );
+  }
+  const data = (await res.json()) as { entity: { uid: string } };
+  return data.entity.uid;
+}
+
+async function resolveCompanyFromMemberships(token: string): Promise<string> {
+  const res = await vaultApiFetch({
+    token,
+    path: '/membership/me',
+  });
+  if (!res.ok) {
+    throw new Error("Failed to fetch memberships — run `hq login` and try again");
+  }
+  const data = (await res.json()) as { memberships: MembershipEntry[] };
+  const active = data.memberships.filter((m) => m.status === 'active');
+  if (active.length === 0) {
+    throw new Error('No active company memberships found. Use --company <slug> to specify.');
+  }
+  if (active.length === 1) {
+    return active[0].companyUid;
+  }
+  const uids = active.map((m) => m.companyUid).join(', ');
+  throw new Error(
+    `Multiple companies found (${uids}). Use --company <slug> to specify which one.`,
+  );
+}
+
+export async function getCompanyUid(
+  token: string,
+  companySlug: string | undefined,
+): Promise<string> {
+  if (companySlug) {
+    return resolveCompanyUid(token, companySlug);
+  }
+  return resolveCompanyFromMemberships(token);
+}