@sanity/runtime-cli 1.2.1 → 1.3.1

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @sanity/runtime-cli
 $ sanity COMMAND
 running command...
 $ sanity (--version)
-@sanity/runtime-cli/1.2.1 linux-x64 node-v22.14.0
+@sanity/runtime-cli/1.3.1 linux-x64 node-v22.14.0
 $ sanity --help [COMMAND]
 USAGE
   $ sanity COMMAND
@@ -31,6 +31,7 @@ USAGE
 <!-- commands -->
 * [`sanity blueprints deploy`](#sanity-blueprints-deploy)
 * [`sanity blueprints info`](#sanity-blueprints-info)
+* [`sanity blueprints logs`](#sanity-blueprints-logs)
 * [`sanity blueprints plan`](#sanity-blueprints-plan)
 * [`sanity functions dev`](#sanity-functions-dev)
 * [`sanity functions invoke ID`](#sanity-functions-invoke-id)
@@ -63,7 +64,7 @@ EXAMPLES
   $ sanity blueprints deploy
 ```
 
-_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/blueprints/deploy.ts)_
+_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.1/src/commands/blueprints/deploy.ts)_
 
 ## `sanity blueprints info`
 
@@ -80,7 +81,32 @@ EXAMPLES
   $ sanity blueprints info
 ```
 
-_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/blueprints/info.ts)_
+_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.1/src/commands/blueprints/info.ts)_
+
+## `sanity blueprints logs`
+
+Display logs for a Blueprint stack
+
+```
+USAGE
+  $ sanity blueprints logs [-s <value>] [-w]
+
+FLAGS
+  -s, --stack-id=<value>  Stack ID to fetch logs for (optional if running in a blueprint directory)
+  -w, --watch             Watch for new logs (streaming mode)
+
+DESCRIPTION
+  Display logs for a Blueprint stack
+
+EXAMPLES
+  $ sanity blueprints logs
+
+  $ sanity blueprints logs --stack-id <stack-id>
+
+  $ sanity blueprints logs --watch
+```
+
+_See code: [src/commands/blueprints/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.1/src/commands/blueprints/logs.ts)_
 
 ## `sanity blueprints plan`
 
@@ -97,7 +123,7 @@ EXAMPLES
   $ sanity blueprints plan
 ```
 
-_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/blueprints/plan.ts)_
+_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.1/src/commands/blueprints/plan.ts)_
 
 ## `sanity functions dev`
 
@@ -117,7 +143,7 @@ EXAMPLES
   $ sanity functions dev --port 8974
 ```
 
-_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/functions/dev.ts)_
+_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.1/src/commands/functions/dev.ts)_
 
 ## `sanity functions invoke ID`
 
@@ -143,7 +169,7 @@ EXAMPLES
   $ sanity functions invoke <ID> --file 'payload.json'
 ```
 
-_See code: [src/commands/functions/invoke.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/functions/invoke.ts)_
+_See code: [src/commands/functions/invoke.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.1/src/commands/functions/invoke.ts)_
 
 ## `sanity functions logs ID`
 
@@ -163,7 +189,7 @@ EXAMPLES
   $ sanity functions logs <ID>
 ```
 
-_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/functions/logs.ts)_
+_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.1/src/commands/functions/logs.ts)_
 
 ## `sanity functions test PATH`
 
@@ -192,7 +218,7 @@ EXAMPLES
   $ sanity functions test ./test.ts --data '{ "id": 1 }' --timeout 60
 ```
 
-_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/functions/test.ts)_
+_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.1/src/commands/functions/test.ts)_
 
 ## `sanity help [COMMAND]`
 

package/dist/actions/blueprints/logs.d.ts

@@ -0,0 +1,7 @@
+import type { BlueprintLog } from '../../utils/types.js';
+export declare function getLogs(stackId: string, projectId: string, token: string): Promise<{
+    logs: BlueprintLog[];
+    ok: boolean;
+    error: string | null;
+}>;
+export declare function streamLogs(stackId: string, projectId: string, token: string, onLog: (log: BlueprintLog) => void, onOpen: () => void, onError: (error: string) => void): () => void;

package/dist/actions/blueprints/logs.js

@@ -0,0 +1,79 @@
+import { EventSource } from 'eventsource';
+import config from '../../config.js';
+const { blueprints } = config.server;
+export async function getLogs(stackId, projectId, token) {
+    const response = await fetch(`${blueprints}/vX/blueprints/logs?stackId=${stackId}`, {
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+            'X-Sanity-Scope-Type': 'project',
+            'X-Sanity-Scope-Id': projectId,
+        },
+        method: 'GET',
+    });
+    const result = await response.json();
+    return {
+        ok: response.ok,
+        error: response.ok ? null : result.message || 'Unknown error',
+        logs: response.ok ? result : [],
+    };
+}
+export function streamLogs(stackId, projectId, token, onLog, onOpen, onError) {
+    const url = new URL(`${blueprints}/vX/blueprints/logs/stream`);
+    url.searchParams.append('stackId', stackId);
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        'X-Sanity-Scope-Type': 'project',
+        'X-Sanity-Scope-Id': projectId,
+    };
+    const eventSource = new EventSource(url.toString(), {
+        fetch: (input, init) => fetch(input, {
+            ...init,
+            headers: {
+                ...init?.headers,
+                ...headers,
+            },
+        }),
+    });
+    eventSource.onopen = onOpen;
+    eventSource.onmessage = (event) => {
+        try {
+            const log = JSON.parse(event.data);
+            onLog(log);
+        }
+        catch (err) {
+            onError(`Failed to parse log data: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    eventSource.addEventListener('logs', (event) => {
+        try {
+            const logData = JSON.parse(event.data);
+            // usually an array
+            if (Array.isArray(logData)) {
+                for (const log of logData)
+                    onLog(log);
+            }
+            else {
+                onLog(logData);
+            }
+        }
+        catch (err) {
+            console.error('Error parsing logs event:', err);
+        }
+    });
+    eventSource.onerror = (err) => {
+        onError('Connection to log stream failed or was closed');
+        if (eventSource.readyState === eventSource.CLOSED) {
+            console.log('Connection is CLOSED');
+        }
+        else if (eventSource.readyState === eventSource.CONNECTING) {
+            console.log('Connection is attempting to reconnect...');
+            return; // Don't close if trying to reconnect
+        }
+        eventSource.close();
+    };
+    return () => {
+        eventSource.close();
+    };
+}

package/dist/actions/blueprints/operations.d.ts

@@ -0,0 +1,18 @@
+import type { BlueprintOperation } from '../../utils/types.js';
+export declare function getOperation({ stackId, operationId, projectId, }: {
+    stackId: string;
+    operationId: string;
+    projectId: string;
+}): Promise<{
+    ok: boolean;
+    error: string | null;
+    operation: BlueprintOperation | null;
+}>;
+export declare function listOperations({ stackId, projectId, }: {
+    stackId: string;
+    projectId: string;
+}): Promise<{
+    ok: boolean;
+    error: string | null;
+    operations: BlueprintOperation[];
+}>;

package/dist/actions/blueprints/operations.js

@@ -0,0 +1,52 @@
+import config from '../../config.js';
+const { blueprints } = config.server;
+function getHeaders(projectId) {
+    return {
+        Authorization: `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+        'X-Sanity-Scope-Type': 'project',
+        'X-Sanity-Scope-Id': projectId,
+    };
+}
+export async function getOperation({ stackId, operationId, projectId, }) {
+    const path = `${blueprints}/vX/blueprints/stacks/${stackId}/operations/${operationId}`;
+    const response = await fetch(path, {
+        method: 'GET',
+        headers: getHeaders(projectId),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        return {
+            ok: false,
+            error: errorText || 'Failed to fetch operation details',
+            operation: null,
+        };
+    }
+    const operation = await response.json();
+    return {
+        ok: true,
+        error: null,
+        operation,
+    };
+}
+export async function listOperations({ stackId, projectId, }) {
+    const path = `${blueprints}/vX/blueprints/stacks/${stackId}/operations`;
+    const response = await fetch(path, {
+        method: 'GET',
+        headers: getHeaders(projectId),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        return {
+            ok: false,
+            error: errorText || 'Failed to fetch operations',
+            operations: [],
+        };
+    }
+    const operations = await response.json();
+    return {
+        ok: true,
+        error: null,
+        operations,
+    };
+}

package/dist/actions/blueprints/read-blueprint.d.ts

@@ -1,2 +1,7 @@
 import type { Blueprint } from '../../utils/types.js';
-export default function readBlueprint(): Blueprint;
+export default function readBlueprintOnDisk(): {
+    document: Blueprint;
+    path: string;
+    fileName: string;
+    extension: string;
+};

package/dist/actions/blueprints/read-blueprint.js

@@ -1,17 +1,43 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { extname, join } from 'node:path';
 import { cwd } from 'node:process';
-export default function readBlueprint() {
+const SUPPORTED_FILE_NAMES_IN_PRIORITY_ORDER = [
+    'blueprint.json',
+    // 'blueprint.js',
+    // 'blueprint.mjs',
+    // 'blueprint.cjs',
+    // 'blueprint.ts',
+];
+function findBlueprintFile() {
+    for (const fileName of SUPPORTED_FILE_NAMES_IN_PRIORITY_ORDER) {
+        const filePath = join(cwd(), fileName);
+        if (existsSync(filePath)) {
+            return { path: filePath, fileName, extension: extname(filePath) };
+        }
+    }
+    return null;
+}
+export default function readBlueprintOnDisk() {
     try {
-        const blueprintPath = join(cwd(), 'blueprint.json');
-        if (!existsSync(blueprintPath)) {
-            throw Error('Could not find blueprint.json');
+        const blueprintPath = findBlueprintFile();
+        if (!blueprintPath)
+            throw Error('Could not find Blueprint file');
+        const { path, fileName, extension } = blueprintPath;
+        let readBlueprint;
+        let blueprintJson;
+        if (extension === '.json') {
+            readBlueprint = readFileSync(path, 'utf8').toString();
+            blueprintJson = JSON.parse(readBlueprint);
+            // } else if (extension === '.js' || extension === '.mjs') {
+            //   const blueprintModule = require(path)
+            //   blueprintJson = blueprintModule.default
+        }
+        else {
+            throw Error(`Unsupported blueprint file extension: ${extension}`);
         }
-        const readBlueprint = readFileSync(blueprintPath, 'utf8').toString();
-        const blueprintJson = JSON.parse(readBlueprint);
-        return blueprintJson;
+        return { document: blueprintJson, path, fileName, extension };
     }
     catch (err) {
-        throw Error('Unable to parse blueprint.json');
+        throw Error(`Unable to parse Blueprint file: ${err}`);
     }
 }

package/dist/actions/blueprints/stacks.d.ts

@@ -1,22 +1,50 @@
 import type { BlueprintJob } from '../../utils/types.js';
-declare function listStacks(): Promise<{
+declare function listStacks({ projectId }: {
+    projectId: string;
+}): Promise<{
     ok: boolean;
     error: any;
     stacks: any;
 }>;
-declare function getStack(stackId: string): Promise<{
+declare function getStackByName({ name, projectId }: {
+    name: string;
+    projectId: string;
+}): Promise<{
+    ok: boolean;
+    error: null;
+    stack: null;
+    stackId: null;
+    availableStacks: any;
+} | {
+    ok: boolean;
+    error: any;
+    stack: any;
+    stackId: any;
+    availableStacks?: undefined;
+}>;
+declare function getStack({ stackId, projectId }: {
+    stackId: string;
+    projectId: string;
+}): Promise<{
     ok: boolean;
     error: any;
     stack: any;
 }>;
-declare function createStack(blueprint: BlueprintJob): Promise<{
+declare function createStack({ blueprint, projectId }: {
+    blueprint: BlueprintJob;
+    projectId: string;
+}): Promise<{
     ok: boolean;
     error: any;
     stack: any;
 }>;
-declare function updateStack(stackId: string, blueprint: BlueprintJob): Promise<{
+declare function updateStack({ stackId, blueprint, projectId, }: {
+    stackId: string;
+    blueprint: BlueprintJob;
+    projectId: string;
+}): Promise<{
     ok: boolean;
     error: any;
     stack: any;
 }>;
-export { listStacks, getStack, createStack, updateStack };
+export { listStacks, getStack, createStack, updateStack, getStackByName };

package/dist/actions/blueprints/stacks.js

@@ -1,13 +1,18 @@
 import config from '../../config.js';
 const { blueprints } = config.server;
-const HEADERS = {
-    Authorization: `Bearer ${config.token}`,
-    'Content-Type': 'application/json',
-};
-async function listStacks() {
-    const response = await fetch(`${blueprints}/vX/stacks`, {
+function getHeaders(projectId) {
+    return {
+        Authorization: `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+        'X-Sanity-Scope-Type': 'project',
+        'X-Sanity-Scope-Id': projectId,
+    };
+}
+async function listStacks({ projectId }) {
+    const path = `${blueprints}/vX/blueprints/stacks`;
+    const response = await fetch(path, {
         method: 'GET',
-        headers: HEADERS,
+        headers: getHeaders(projectId),
     });
     const stacks = await response.json();
     return {
@@ -16,10 +21,39 @@ async function listStacks() {
         stacks,
     };
 }
-async function getStack(stackId) {
-    const response = await fetch(`${blueprints}/vX/stacks/${stackId}`, {
+async function getStackByName({ name, projectId }) {
+    const { ok, stacks, error } = await listStacks({ projectId });
+    if (!ok || !stacks) {
+        return {
+            ok: false,
+            error: error || 'Failed to retrieve stacks',
+            stack: null,
+            stackId: null,
+        };
+    }
+    const foundStack = stacks.find((stack) => stack.name === name);
+    if (!foundStack) {
+        return {
+            ok: true,
+            error: null,
+            stack: null,
+            stackId: null,
+            availableStacks: stacks.map((s) => s.name),
+        };
+    }
+    const stackResult = await getStack({ stackId: foundStack.id, projectId });
+    return {
+        ok: stackResult.ok,
+        error: stackResult.error,
+        stack: stackResult.stack,
+        stackId: foundStack.id,
+    };
+}
+async function getStack({ stackId, projectId }) {
+    const path = `${blueprints}/vX/blueprints/stacks/${stackId}`;
+    const response = await fetch(path, {
         method: 'GET',
-        headers: HEADERS,
+        headers: getHeaders(projectId),
     });
     const stack = await response.json();
     return {
@@ -28,10 +62,11 @@ async function getStack(stackId) {
         stack,
     };
 }
-async function createStack(blueprint) {
-    const response = await fetch(`${blueprints}/vX/stacks`, {
+async function createStack({ blueprint, projectId }) {
+    const path = `${blueprints}/vX/blueprints/stacks`;
+    const response = await fetch(path, {
         method: 'POST',
-        headers: HEADERS,
+        headers: getHeaders(projectId),
         body: JSON.stringify(blueprint),
     });
     const stack = await response.json();
@@ -41,10 +76,11 @@ async function createStack(blueprint) {
         stack,
     };
 }
-async function updateStack(stackId, blueprint) {
-    const response = await fetch(`${blueprints}/vX/stacks/${stackId}`, {
+async function updateStack({ stackId, blueprint, projectId, }) {
+    const path = `${blueprints}/vX/blueprints/stacks/${stackId}`;
+    const response = await fetch(path, {
         method: 'PUT',
-        headers: HEADERS,
+        headers: getHeaders(projectId),
         body: JSON.stringify(blueprint),
     });
     const stack = await response.json();
@@ -54,4 +90,4 @@ async function updateStack(stackId, blueprint) {
         stack,
     };
 }
-export { listStacks, getStack, createStack, updateStack };
+export { listStacks, getStack, createStack, updateStack, getStackByName };

package/dist/actions/blueprints/stash-asset.d.ts

@@ -1,5 +1,8 @@
 import type { BlueprintResource } from '../../utils/types.js';
-export declare function stashAsset(resource: BlueprintResource): Promise<{
+export declare function stashAsset({ resource, projectId, }: {
+    resource: BlueprintResource;
+    projectId: string;
+}): Promise<{
     success: boolean;
     assetId: any;
     error?: undefined;

package/dist/actions/blueprints/stash-asset.js

@@ -4,7 +4,15 @@ import { cwd } from 'node:process';
 import JSZip from 'jszip';
 import config from '../../config.js';
 const { blueprints } = config.server;
-export async function stashAsset(resource) {
+function getHeaders(projectId) {
+    return {
+        Authorization: `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+        'X-Sanity-Scope-Type': 'project',
+        'X-Sanity-Scope-Id': projectId,
+    };
+}
+export async function stashAsset({ resource, projectId, }) {
     try {
         // Read the function source
         const source = await fs.readFileSync(path.join(cwd(), resource.src), 'utf8');
@@ -14,19 +22,16 @@ export async function stashAsset(resource) {
         const zipBuffer = await zip.generateAsync({ type: 'nodebuffer' });
         const base64Zip = zipBuffer.toString('base64');
         // Stash the asset
-        const assetResponse = await fetch(`${blueprints}/assets/stash`, {
+        const assetResponse = await fetch(`${blueprints}/vX/blueprints/assets/stash`, {
             method: 'POST',
-            headers: {
-                Authorization: `Bearer ${config.token}`,
-                'Content-Type': 'application/json',
-            },
+            headers: getHeaders(projectId),
             body: JSON.stringify({
                 file: base64Zip,
                 filename: `${resource.name}.zip`,
             }),
         });
         const assetJson = await assetResponse.json();
-        console.debug('ASSET RESPONSE:', assetJson);
+        // console.debug('ASSET RESPONSE:', assetJson)
         if (assetResponse.ok) {
             return { success: true, assetId: assetJson.id };
         }

package/dist/actions/functions/invoke.js

@@ -1,15 +1,18 @@
 import config from '../../config.js';
 import buildPayload from '../../utils/build-payload.js';
 const { functions } = config.server;
+function getHeaders() {
+    return {
+        Authorization: `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+    };
+}
 export async function invoke(id, options) {
     const payload = buildPayload(options);
-    // eslint-disable-next-line n/no-unsupported-features/node-builtins
     const response = await fetch(`${functions}/vX/functions/${id}/invoke`, {
         body: JSON.stringify({ data: payload }),
-        headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json',
-        },
+        headers: getHeaders(),
         method: 'POST',
     });
     const json = await response.json();

package/dist/commands/blueprints/deploy.js

@@ -1,70 +1,64 @@
 import { Command } from '@oclif/core';
-import readBlueprint from '../../actions/blueprints/read-blueprint.js';
-import { createStack, listStacks, updateStack } from '../../actions/blueprints/stacks.js';
+import readBlueprintOnDisk from '../../actions/blueprints/read-blueprint.js';
+import { createStack, getStackByName, updateStack } from '../../actions/blueprints/stacks.js';
 import { stashAsset } from '../../actions/blueprints/stash-asset.js';
+import { green, red, yellow } from '../../utils/display/colors.js';
 import Spinner from '../../utils/spinner.js';
 export default class Deploy extends Command {
     static description = 'Deploy a Blueprint';
     static examples = ['<%= config.bin %> <%= command.id %>'];
     async run() {
-        const { displayName, name, projectId, resources } = readBlueprint();
+        const { document } = readBlueprintOnDisk();
+        const { displayName, name, projectId, resources } = document;
         const s = new Spinner();
-        s.start('Deploying blueprint...');
         const functionResources = resources.filter((r) => r.kind === 'function');
         // First stash all function assets
         if (functionResources.length > 0) {
-            s.stop('Preparing functions...');
             for (const resource of functionResources) {
                 const fnSpinner = new Spinner();
                 fnSpinner.start(`Processing ${resource.name}...`);
-                const result = await stashAsset(resource);
+                const result = await stashAsset({ resource, projectId });
                 if (result.success) {
-                    resource.assetId = result.assetId;
-                    fnSpinner.stop(`✓ ${resource.name} (${result.assetId})`);
-                    this.log(`   Source: ${resource.src}`);
+                    const src = resource.src;
+                    resource.src = result.assetId; // TODO: properly reference asset - for now, the API expects the assetId
+                    fnSpinner.stop(`${green('✓')} ${resource.name} <${yellow(result.assetId)}>`);
+                    this.log(`   Source: ${src}`);
                 }
                 else {
-                    fnSpinner.stop(`✗ Failed to process ${resource.name}`);
+                    fnSpinner.stop(`${red('✗')} Failed to process ${resource.name}`);
                     this.log(`   Error: ${result.error}`);
                     return;
                 }
             }
-            this.log('│');
-            s.start('Looking for existing stack...');
         }
-        // Check for existing stack
-        const { ok: stacksOk, stacks, error: stacksError } = await listStacks();
-        if (!stacksOk) {
-            s.stop('Failed to list stacks');
-            this.log(`Error: ${stacksError || 'Unknown error'}`);
+        s.start('Looking for existing stack...');
+        const { ok, error, stackId: existingStackId, } = await getStackByName({
+            name,
+            projectId,
+        });
+        if (!ok) {
+            s.stop(`${red('Failed')} to list stacks`);
+            this.log(`Error: ${error || 'Unknown error'}`);
             return;
         }
-        const existingStack = stacks.find((st) => st.name === name);
         const blueprint = {
             name,
             projectId,
-            document: {
-                resources: resources.map((r) => {
-                    if (r.kind === 'function') {
-                        return { ...r, src: r.assetId };
-                    }
-                    return r;
-                }),
-            },
+            document: { resources },
         };
         this.debug('BLUEPRINT DOCUMENT:', blueprint);
-        // Create or update stack
-        const { ok, stack, error } = existingStack
-            ? await updateStack(existingStack.id, blueprint)
-            : await createStack(blueprint);
+        const { ok: deployOk, stack, error: deployError, } = existingStackId
+            ? await updateStack({ stackId: existingStackId, blueprint, projectId })
+            : await createStack({ blueprint, projectId });
         this.debug('STACK RESPONSE:', stack);
-        if (ok) {
-            s.stop(`Stack ${existingStack ? 'updated' : 'created'}! (${stack.id})`);
-            this.log('Use `blueprints info` to check deployment status');
+        if (deployOk) {
+            s.stop(`${green('Success!')} Stack ${existingStackId ? 'updated' : 'created'} <${yellow(stack.id)}>`);
+            this.log('\nUse `sanity blueprints info` to check deployment status');
         }
         else {
-            s.stop(`Failed to ${existingStack ? 'update' : 'create'} stack`);
-            this.log(`Error: ${error || 'Unknown error'}`);
+            this.debug('STACK ERROR RESPONSE:', stack);
+            s.stop(`${red('Failed')} to ${existingStackId ? 'update' : 'create'} stack`);
+            this.log(`Error: ${deployError || 'Unknown error'}`);
         }
     }
 }