@hyperdrive.bot/sign-cli 0.1.4 → 0.1.6

package/dist/commands/api.js

@@ -46,7 +46,7 @@ export default class Api extends Command {
             let fullUrl;
             if (flags.module) {
                 const { getManifest } = await import('../lib/manifest.js');
-                const manifest = await getManifest(client);
+                const manifest = await getManifest();
                 const resource = Object.values(manifest.resources).find(r => r.module === flags.module);
                 if (resource) {
                     fullUrl = `${resource.apiGateway}${path}`;

package/dist/commands/modules/list.js

@@ -6,7 +6,6 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { getManifest, listResources } from '../../lib/manifest.js';
-import { createSignClient } from '../../lib/sign-api.js';
 export default class ModulesList extends Command {
     static description = 'List all available API resources and actions';
     static examples = [
@@ -21,8 +20,7 @@ export default class ModulesList extends Command {
     async run() {
         const { flags } = await this.parse(ModulesList);
         try {
-            const client = createSignClient();
-            const manifest = await getManifest(client, flags.refresh);
+            const manifest = await getManifest(undefined, flags.refresh);
             const resources = listResources(manifest);
             if (flags.json) {
                 this.log(JSON.stringify(resources, null, 2));

package/dist/hooks/command-not-found.js

@@ -24,7 +24,7 @@ const hook = async function (opts) {
         const resource = parts[0];
         try {
             const client = createSignClient();
-            const manifest = await getManifest(client);
+            const manifest = await getManifest();
             const res = manifest.resources[resource];
             if (res) {
                 console.log(`\nResource: ${resource} (module: ${res.module})\n`);
@@ -56,11 +56,11 @@ const hook = async function (opts) {
         if (resource === 'manifest' && action === 'refresh') {
             const { clearManifestCache } = await import('../lib/manifest.js');
             await clearManifestCache();
-            const manifest = await getManifest(client, true);
+            const manifest = await getManifest(undefined, true);
             console.log(`Manifest refreshed: ${Object.keys(manifest.resources).length} resources discovered.`);
             return;
         }
-        const manifest = await getManifest(client);
+        const manifest = await getManifest();
         const match = resolveAction(manifest, resource, action);
         if (!match) {
             const res = manifest.resources[resource];
@@ -90,7 +90,7 @@ const hook = async function (opts) {
     catch (error) {
         const err = error;
         if (err.message.includes('Missing required argument')) {
-            const match = resolveAction(await getManifest(createSignClient()), resource, action);
+            const match = resolveAction(await getManifest(), resource, action);
             const argsStr = match?.action.args.map(a => `<${a}>`).join(' ') || '';
             console.error(`Error: ${err.message}`);
             console.error(`Usage: sign ${resource} ${action} ${argsStr}`);

package/dist/lib/manifest.d.ts

@@ -1,8 +1,13 @@
 /**
  * Manifest Client
  *
- * Fetches and caches the API manifest from the backend.
+ * Fetches and caches the API manifest from the tenant domain.
  * The manifest contains all discoverable resources + actions.
+ *
+ * Flow:
+ *   1. After login, CLI fetches https://{domain}/tenant/manifest
+ *   2. Cached locally at ~/.sign/manifest.{domain}.json
+ *   3. Refetched daily or on "sign manifest refresh"
  */
 export interface ManifestAction {
     name: string;
@@ -23,13 +28,13 @@ export interface Manifest {
     resources: Record<string, ManifestResource>;
 }
 /**
- * Get the manifest — from cache if fresh, otherwise from the API
+ * Get the manifest -- from cache if fresh, otherwise from the tenant domain
  */
-export declare const getManifest: (apiClient: {
+export declare const getManifest: (_apiClient?: {
     get: (path: string) => Promise<unknown>;
 }, forceRefresh?: boolean) => Promise<Manifest>;
 /**
- * Clear the cached manifest
+ * Clear the cached manifest for the current domain
  */
 export declare const clearManifestCache: () => Promise<void>;
 /**

package/dist/lib/manifest.js

@@ -1,38 +1,79 @@
 /**
  * Manifest Client
  *
- * Fetches and caches the API manifest from the backend.
+ * Fetches and caches the API manifest from the tenant domain.
  * The manifest contains all discoverable resources + actions.
+ *
+ * Flow:
+ *   1. After login, CLI fetches https://{domain}/tenant/manifest
+ *   2. Cached locally at ~/.sign/manifest.{domain}.json
+ *   3. Refetched daily or on "sign manifest refresh"
  */
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 // --- Config ---
 const CACHE_DIR = join(homedir(), '.sign');
-const CACHE_FILE = join(CACHE_DIR, 'manifest.json');
-const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+/**
+ * Get cache file path for a domain
+ */
+const getCacheFile = (domain) => {
+    const safeDomain = domain.replace(/[^a-zA-Z0-9.-]/g, '_');
+    return join(CACHE_DIR, `manifest.${safeDomain}.json`);
+};
+/**
+ * Resolve the tenant domain from stored credentials
+ */
+const resolveDomain = () => {
+    // Check default-domain file
+    const defaultDomainFile = join(CACHE_DIR, 'default-domain');
+    try {
+        if (existsSync(defaultDomainFile)) {
+            const domain = readFileSync(defaultDomainFile, 'utf-8').trim();
+            if (domain)
+                return domain;
+        }
+    }
+    catch { /* ignore */ }
+    // Check for any credential file
+    try {
+        const files = readdirSync(CACHE_DIR);
+        const credFile = files.find((f) => f.startsWith('credentials.'));
+        if (credFile) {
+            return credFile.replace('credentials.', '');
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+};
 /**
- * Get the manifest — from cache if fresh, otherwise from the API
+ * Get the manifest -- from cache if fresh, otherwise from the tenant domain
  */
-export const getManifest = async (apiClient, forceRefresh = false) => {
+export const getManifest = async (_apiClient, forceRefresh = false) => {
+    const domain = resolveDomain();
+    if (!domain) {
+        throw new Error('Not authenticated. Run "sign auth login --domain <domain>" first.');
+    }
     if (!forceRefresh) {
-        const cached = await loadCachedManifest();
+        const cached = await loadCachedManifest(domain);
         if (cached)
             return cached;
     }
-    const manifest = await fetchManifest(apiClient);
-    await cacheManifest(manifest);
+    const manifest = await fetchManifest(domain);
+    await cacheManifest(domain, manifest);
     return manifest;
 };
 /**
  * Load manifest from local cache if it exists and is fresh
  */
-const loadCachedManifest = async () => {
+const loadCachedManifest = async (domain) => {
+    const cacheFile = getCacheFile(domain);
     try {
-        if (!existsSync(CACHE_FILE))
+        if (!existsSync(cacheFile))
             return null;
-        const raw = await readFile(CACHE_FILE, 'utf-8');
+        const raw = await readFile(cacheFile, 'utf-8');
         const cached = JSON.parse(raw);
         const age = Date.now() - new Date(cached.fetchedAt).getTime();
         if (age > CACHE_TTL_MS)
@@ -44,47 +85,48 @@ const loadCachedManifest = async () => {
     }
 };
 /**
- * Fetch manifest from the tenants API Gateway (no auth required).
- * Uses the bootstrap URL base to reach the tenants gateway directly.
+ * Fetch manifest from the tenant domain.
+ * Uses plain HTTPS -- the manifest endpoint is on the tenant's CloudFront.
  */
-const fetchManifest = async (apiClient) => {
-    // The manifest endpoint is on the tenants gateway (same as bootstrap).
-    // It's unauthenticated, so we fetch it with plain HTTP.
-    const bootstrapUrl = process.env.SIGN_BOOTSTRAP_URL || 'https://oo2wp0ax27.execute-api.us-east-1.amazonaws.com/dev/tenant/bootstrap-dev';
-    const baseUrl = bootstrapUrl.replace(/\/tenant\/bootstrap.*$/, '');
-    const manifestUrl = `${baseUrl}/tenant/manifest`;
+const fetchManifest = async (domain) => {
+    const manifestUrl = `https://${domain}/tenant/manifest`;
     const response = await fetch(manifestUrl);
     if (!response.ok) {
-        throw new Error(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
+        throw new Error(`Failed to fetch manifest from ${domain}: ${response.status} ${response.statusText}`);
     }
     return await response.json();
 };
 /**
- * Cache manifest to local filesystem
+ * Cache manifest to local filesystem (per-domain)
  */
-const cacheManifest = async (manifest) => {
+const cacheManifest = async (domain, manifest) => {
     try {
         if (!existsSync(CACHE_DIR)) {
             await mkdir(CACHE_DIR, { recursive: true });
         }
         const cached = {
             fetchedAt: new Date().toISOString(),
+            domain,
             manifest
         };
-        await writeFile(CACHE_FILE, JSON.stringify(cached, null, 2));
+        await writeFile(getCacheFile(domain), JSON.stringify(cached, null, 2));
     }
     catch {
         // Cache write failure is non-fatal
     }
 };
 /**
- * Clear the cached manifest
+ * Clear the cached manifest for the current domain
  */
 export const clearManifestCache = async () => {
+    const domain = resolveDomain();
+    if (!domain)
+        return;
     try {
-        if (existsSync(CACHE_FILE)) {
+        const cacheFile = getCacheFile(domain);
+        if (existsSync(cacheFile)) {
             const { unlink } = await import('node:fs/promises');
-            await unlink(CACHE_FILE);
+            await unlink(cacheFile);
         }
     }
     catch {

package/dist/lib/sign-api.d.ts

@@ -11,7 +11,7 @@ import { SigV4ApiClient } from '@hyperdrive.bot/cli-auth';
 export declare class SignApiClient extends SigV4ApiClient {
     constructor(domain?: string);
     /**
-     * GET request to the primary API (tenants gateway)
+     * GET request to the primary API (sign gateway)
      */
     get<T = unknown>(path: string): Promise<T>;
     /**

package/dist/lib/sign-api.js

@@ -25,7 +25,7 @@ export class SignApiClient extends SigV4ApiClient {
         });
     }
     /**
-     * GET request to the primary API (tenants gateway)
+     * GET request to the primary API (sign gateway)
      */
     async get(path) {
         return this.makeSignedRequest('GET', path);

package/oclif.manifest.json

@@ -120,5 +120,5 @@
       ]
     }
   },
-  "version": "0.1.4"
+  "version": "0.1.6"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hyperdrive.bot/sign-cli",
   "description": "Sign CLI — runtime-discovered API client for the Sign platform",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "author": "marcelomarra",
   "bin": {
     "sign": "./bin/run.js"