ph-cmd 6.0.0-dev.22 → 6.0.0-dev.23

package/build/cli.js

@@ -653509,7 +653509,7 @@ globstar while`, file2, fr9, pattern, pr9, swallowee);
         throw err;
     }
   }
-  function fetch(url4, dest, proxy) {
+  function fetch2(url4, dest, proxy) {
     return new Promise((fulfil, reject) => {
       let options8 = url4;
       if (proxy) {
@@ -653525,7 +653525,7 @@ globstar while`, file2, fr9, pattern, pr9, swallowee);
         if (code >= 400) {
           reject({ code, message: response.statusMessage });
         } else if (code >= 300) {
-          fetch(response.headers.location, dest, proxy).then(fulfil, reject);
+          fetch2(response.headers.location, dest, proxy).then(fulfil, reject);
         } else {
           response.pipe(fs__default["default"].createWriteStream(dest)).on("finish", () => fulfil()).on("error", reject);
         }
@@ -653781,7 +653781,7 @@ globstar while`, file2, fr9, pattern, pr9, swallowee);
               code: "DOWNLOADING",
               message: `downloading ${url4} to ${file2}`
             });
-            await fetch(url4, file2, this.proxy);
+            await fetch2(url4, file2, this.proxy);
           }
         }
       } catch (err) {
@@ -659288,7 +659288,7 @@ var exports_version = {};
 __export(exports_version, {
   version: () => version2
 });
-var version2 = "6.0.0-dev.21";
+var version2 = "6.0.0-dev.22";
 
 // ../../node_modules/.pnpm/imurmurhash@0.1.4/node_modules/imurmurhash/imurmurhash.js
 var require_imurmurhash = __commonJS((exports, module3) => {
@@ -692993,9 +692993,605 @@ PH CLI package manager: ${packageManager}
 }
 
 // src/commands/init.ts
+init_source();
 var import_cmd_ts12 = __toESM(require_cjs(), 1);
 var import_enquirer2 = __toESM(require_enquirer(), 1);
 var import_semver4 = __toESM(require_semver2(), 1);
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/classes/ClientError.js
+class ClientError extends Error {
+  response;
+  request;
+  constructor(response, request) {
+    const message = `${ClientError.extractMessage(response)}: ${JSON.stringify({
+      response,
+      request
+    })}`;
+    super(message);
+    Object.setPrototypeOf(this, ClientError.prototype);
+    this.response = response;
+    this.request = request;
+    if (typeof Error.captureStackTrace === `function`) {
+      Error.captureStackTrace(this, ClientError);
+    }
+  }
+  static extractMessage(response) {
+    return response.errors?.[0]?.message ?? `GraphQL Error (Code: ${String(response.status)})`;
+  }
+}
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/lib/prelude.js
+var uppercase2 = (str2) => str2.toUpperCase();
+var callOrIdentity = (value2) => {
+  return typeof value2 === `function` ? value2() : value2;
+};
+var zip = (a5, b25) => a5.map((k8, i4) => [k8, b25[i4]]);
+var HeadersInitToPlainObject = (headers) => {
+  let oHeaders = {};
+  if (headers instanceof Headers) {
+    oHeaders = HeadersInstanceToPlainObject(headers);
+  } else if (Array.isArray(headers)) {
+    headers.forEach(([name, value2]) => {
+      if (name && value2 !== undefined) {
+        oHeaders[name] = value2;
+      }
+    });
+  } else if (headers) {
+    oHeaders = headers;
+  }
+  return oHeaders;
+};
+var HeadersInstanceToPlainObject = (headers) => {
+  const o5 = {};
+  headers.forEach((v25, k8) => {
+    o5[k8] = v25;
+  });
+  return o5;
+};
+var tryCatch = (fn9) => {
+  try {
+    const result = fn9();
+    if (isPromiseLikeValue(result)) {
+      return result.catch((error49) => {
+        return errorFromMaybeError(error49);
+      });
+    }
+    return result;
+  } catch (error49) {
+    return errorFromMaybeError(error49);
+  }
+};
+var errorFromMaybeError = (maybeError) => {
+  if (maybeError instanceof Error)
+    return maybeError;
+  return new Error(String(maybeError));
+};
+var isPromiseLikeValue = (value2) => {
+  return typeof value2 === `object` && value2 !== null && `then` in value2 && typeof value2.then === `function` && `catch` in value2 && typeof value2.catch === `function` && `finally` in value2 && typeof value2.finally === `function`;
+};
+var casesExhausted = (value2) => {
+  throw new Error(`Unhandled case: ${String(value2)}`);
+};
+var isPlainObject3 = (value2) => {
+  return typeof value2 === `object` && value2 !== null && !Array.isArray(value2);
+};
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/functions/batchRequests.js
+var parseBatchRequestArgs = (documentsOrOptions, requestHeaders) => {
+  return documentsOrOptions.documents ? documentsOrOptions : {
+    documents: documentsOrOptions,
+    requestHeaders,
+    signal: undefined
+  };
+};
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/functions/rawRequest.js
+var parseRawRequestArgs = (queryOrOptions, variables, requestHeaders) => {
+  return queryOrOptions.query ? queryOrOptions : {
+    query: queryOrOptions,
+    variables,
+    requestHeaders,
+    signal: undefined
+  };
+};
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/lib/graphql.js
+var import_graphql29 = __toESM(require_graphql2(), 1);
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/lib/http.js
+var ACCEPT_HEADER = `Accept`;
+var CONTENT_TYPE_HEADER = `Content-Type`;
+var CONTENT_TYPE_JSON = `application/json`;
+var CONTENT_TYPE_GQL = `application/graphql-response+json`;
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/lib/graphql.js
+var cleanQuery = (str2) => str2.replace(/([\s,]|#[^\n\r]+)+/g, ` `).trim();
+var isGraphQLContentType = (contentType) => {
+  const contentTypeLower = contentType.toLowerCase();
+  return contentTypeLower.includes(CONTENT_TYPE_GQL) || contentTypeLower.includes(CONTENT_TYPE_JSON);
+};
+var parseGraphQLExecutionResult = (result) => {
+  try {
+    if (Array.isArray(result)) {
+      return {
+        _tag: `Batch`,
+        executionResults: result.map(parseExecutionResult)
+      };
+    } else if (isPlainObject3(result)) {
+      return {
+        _tag: `Single`,
+        executionResult: parseExecutionResult(result)
+      };
+    } else {
+      throw new Error(`Invalid execution result: result is not object or array. 
+Got:
+${String(result)}`);
+    }
+  } catch (e8) {
+    return e8;
+  }
+};
+var parseExecutionResult = (result) => {
+  if (typeof result !== `object` || result === null) {
+    throw new Error(`Invalid execution result: result is not object`);
+  }
+  let errors3 = undefined;
+  let data = undefined;
+  let extensions = undefined;
+  if (`errors` in result) {
+    if (!isPlainObject3(result.errors) && !Array.isArray(result.errors)) {
+      throw new Error(`Invalid execution result: errors is not plain object OR array`);
+    }
+    errors3 = result.errors;
+  }
+  if (`data` in result) {
+    if (!isPlainObject3(result.data) && result.data !== null) {
+      throw new Error(`Invalid execution result: data is not plain object`);
+    }
+    data = result.data;
+  }
+  if (`extensions` in result) {
+    if (!isPlainObject3(result.extensions))
+      throw new Error(`Invalid execution result: extensions is not plain object`);
+    extensions = result.extensions;
+  }
+  return {
+    data,
+    errors: errors3,
+    extensions
+  };
+};
+var isRequestResultHaveErrors = (result) => result._tag === `Batch` ? result.executionResults.some(isExecutionResultHaveErrors) : isExecutionResultHaveErrors(result.executionResult);
+var isExecutionResultHaveErrors = (result) => Array.isArray(result.errors) ? result.errors.length > 0 : Boolean(result.errors);
+var isOperationDefinitionNode = (definition) => {
+  return typeof definition === `object` && definition !== null && `kind` in definition && definition.kind === import_graphql29.Kind.OPERATION_DEFINITION;
+};
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/helpers/analyzeDocument.js
+var import_graphql31 = __toESM(require_graphql2(), 1);
+var import_graphql32 = __toESM(require_graphql2(), 1);
+var extractOperationName = (document2) => {
+  let operationName = undefined;
+  const defs = document2.definitions.filter(isOperationDefinitionNode);
+  if (defs.length === 1) {
+    operationName = defs[0].name?.value;
+  }
+  return operationName;
+};
+var extractIsMutation = (document2) => {
+  let isMutation = false;
+  const defs = document2.definitions.filter(isOperationDefinitionNode);
+  if (defs.length === 1) {
+    isMutation = defs[0].operation === `mutation`;
+  }
+  return isMutation;
+};
+var analyzeDocument = (document2, excludeOperationName) => {
+  const expression = typeof document2 === `string` ? document2 : import_graphql32.print(document2);
+  let isMutation = false;
+  let operationName = undefined;
+  if (excludeOperationName) {
+    return { expression, isMutation, operationName };
+  }
+  const docNode = tryCatch(() => typeof document2 === `string` ? import_graphql31.parse(document2) : document2);
+  if (docNode instanceof Error) {
+    return { expression, isMutation, operationName };
+  }
+  operationName = extractOperationName(docNode);
+  isMutation = extractIsMutation(docNode);
+  return { expression, operationName, isMutation };
+};
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/helpers/defaultJsonSerializer.js
+var defaultJsonSerializer = JSON;
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/helpers/runRequest.js
+var runRequest = async (input) => {
+  const config21 = {
+    ...input,
+    method: input.request._tag === `Single` ? input.request.document.isMutation ? `POST` : uppercase2(input.method ?? `post`) : input.request.hasMutations ? `POST` : uppercase2(input.method ?? `post`),
+    fetchOptions: {
+      ...input.fetchOptions,
+      errorPolicy: input.fetchOptions.errorPolicy ?? `none`
+    }
+  };
+  const fetcher = createFetcher(config21.method);
+  const fetchResponse = await fetcher(config21);
+  if (!fetchResponse.ok) {
+    return new ClientError({ status: fetchResponse.status, headers: fetchResponse.headers }, {
+      query: input.request._tag === `Single` ? input.request.document.expression : input.request.query,
+      variables: input.request.variables
+    });
+  }
+  const result = await parseResultFromResponse(fetchResponse, input.fetchOptions.jsonSerializer ?? defaultJsonSerializer);
+  if (result instanceof Error)
+    throw result;
+  const clientResponseBase = {
+    status: fetchResponse.status,
+    headers: fetchResponse.headers
+  };
+  if (isRequestResultHaveErrors(result) && config21.fetchOptions.errorPolicy === `none`) {
+    const clientResponse = result._tag === `Batch` ? { ...result.executionResults, ...clientResponseBase } : {
+      ...result.executionResult,
+      ...clientResponseBase
+    };
+    return new ClientError(clientResponse, {
+      query: input.request._tag === `Single` ? input.request.document.expression : input.request.query,
+      variables: input.request.variables
+    });
+  }
+  switch (result._tag) {
+    case `Single`:
+      return {
+        ...clientResponseBase,
+        ...executionResultClientResponseFields(config21)(result.executionResult)
+      };
+    case `Batch`:
+      return {
+        ...clientResponseBase,
+        data: result.executionResults.map(executionResultClientResponseFields(config21))
+      };
+    default:
+      casesExhausted(result);
+  }
+};
+var executionResultClientResponseFields = ($params) => (executionResult) => {
+  return {
+    extensions: executionResult.extensions,
+    data: executionResult.data,
+    errors: $params.fetchOptions.errorPolicy === `all` ? executionResult.errors : undefined
+  };
+};
+var parseResultFromResponse = async (response, jsonSerializer) => {
+  const contentType = response.headers.get(CONTENT_TYPE_HEADER);
+  const text = await response.text();
+  if (contentType && isGraphQLContentType(contentType)) {
+    return parseGraphQLExecutionResult(jsonSerializer.parse(text));
+  } else {
+    return parseGraphQLExecutionResult(text);
+  }
+};
+var createFetcher = (method) => async (params) => {
+  const headers = new Headers(params.headers);
+  let searchParams = null;
+  let body = undefined;
+  if (!headers.has(ACCEPT_HEADER)) {
+    headers.set(ACCEPT_HEADER, [CONTENT_TYPE_GQL, CONTENT_TYPE_JSON].join(`, `));
+  }
+  if (method === `POST`) {
+    const $jsonSerializer = params.fetchOptions.jsonSerializer ?? defaultJsonSerializer;
+    body = $jsonSerializer.stringify(buildBody(params));
+    if (typeof body === `string` && !headers.has(CONTENT_TYPE_HEADER)) {
+      headers.set(CONTENT_TYPE_HEADER, CONTENT_TYPE_JSON);
+    }
+  } else {
+    searchParams = buildQueryParams(params);
+  }
+  const init4 = { method, headers, body, ...params.fetchOptions };
+  let url4 = new URL(params.url);
+  let initResolved = init4;
+  if (params.middleware) {
+    const result = await Promise.resolve(params.middleware({
+      ...init4,
+      url: params.url,
+      operationName: params.request._tag === `Single` ? params.request.document.operationName : undefined,
+      variables: params.request.variables
+    }));
+    const { url: urlNew, ...initNew } = result;
+    url4 = new URL(urlNew);
+    initResolved = initNew;
+  }
+  if (searchParams) {
+    searchParams.forEach((value2, name) => {
+      url4.searchParams.append(name, value2);
+    });
+  }
+  const $fetch = params.fetch ?? fetch;
+  return await $fetch(url4, initResolved);
+};
+var buildBody = (params) => {
+  switch (params.request._tag) {
+    case `Single`:
+      return {
+        query: params.request.document.expression,
+        variables: params.request.variables,
+        operationName: params.request.document.operationName
+      };
+    case `Batch`:
+      return zip(params.request.query, params.request.variables ?? []).map(([query, variables]) => ({
+        query,
+        variables
+      }));
+    default:
+      throw casesExhausted(params.request);
+  }
+};
+var buildQueryParams = (params) => {
+  const $jsonSerializer = params.fetchOptions.jsonSerializer ?? defaultJsonSerializer;
+  const searchParams = new URLSearchParams;
+  switch (params.request._tag) {
+    case `Single`: {
+      searchParams.append(`query`, cleanQuery(params.request.document.expression));
+      if (params.request.variables) {
+        searchParams.append(`variables`, $jsonSerializer.stringify(params.request.variables));
+      }
+      if (params.request.document.operationName) {
+        searchParams.append(`operationName`, params.request.document.operationName);
+      }
+      return searchParams;
+    }
+    case `Batch`: {
+      const variablesSerialized = params.request.variables?.map((v25) => $jsonSerializer.stringify(v25)) ?? [];
+      const queriesCleaned = params.request.query.map(cleanQuery);
+      const payload = zip(queriesCleaned, variablesSerialized).map(([query, variables]) => ({
+        query,
+        variables
+      }));
+      searchParams.append(`query`, $jsonSerializer.stringify(payload));
+      return searchParams;
+    }
+    default:
+      throw casesExhausted(params.request);
+  }
+};
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/classes/GraphQLClient.js
+class GraphQLClient {
+  url;
+  requestConfig;
+  constructor(url4, requestConfig = {}) {
+    this.url = url4;
+    this.requestConfig = requestConfig;
+  }
+  rawRequest = async (...args) => {
+    const [queryOrOptions, variables, requestHeaders] = args;
+    const rawRequestOptions = parseRawRequestArgs(queryOrOptions, variables, requestHeaders);
+    const { headers, fetch: fetch2 = globalThis.fetch, method = `POST`, requestMiddleware, responseMiddleware, excludeOperationName, ...fetchOptions } = this.requestConfig;
+    const { url: url4 } = this;
+    if (rawRequestOptions.signal !== undefined) {
+      fetchOptions.signal = rawRequestOptions.signal;
+    }
+    const document2 = analyzeDocument(rawRequestOptions.query, excludeOperationName);
+    const response = await runRequest({
+      url: url4,
+      request: {
+        _tag: `Single`,
+        document: document2,
+        variables: rawRequestOptions.variables
+      },
+      headers: {
+        ...HeadersInitToPlainObject(callOrIdentity(headers)),
+        ...HeadersInitToPlainObject(rawRequestOptions.requestHeaders)
+      },
+      fetch: fetch2,
+      method,
+      fetchOptions,
+      middleware: requestMiddleware
+    });
+    if (responseMiddleware) {
+      await responseMiddleware(response, {
+        operationName: document2.operationName,
+        variables,
+        url: this.url
+      });
+    }
+    if (response instanceof Error) {
+      throw response;
+    }
+    return response;
+  };
+  async request(documentOrOptions, ...variablesAndRequestHeaders) {
+    const [variables, requestHeaders] = variablesAndRequestHeaders;
+    const requestOptions = parseRequestArgs(documentOrOptions, variables, requestHeaders);
+    const { headers, fetch: fetch2 = globalThis.fetch, method = `POST`, requestMiddleware, responseMiddleware, excludeOperationName, ...fetchOptions } = this.requestConfig;
+    const { url: url4 } = this;
+    if (requestOptions.signal !== undefined) {
+      fetchOptions.signal = requestOptions.signal;
+    }
+    const analyzedDocument = analyzeDocument(requestOptions.document, excludeOperationName);
+    const response = await runRequest({
+      url: url4,
+      request: {
+        _tag: `Single`,
+        document: analyzedDocument,
+        variables: requestOptions.variables
+      },
+      headers: {
+        ...HeadersInitToPlainObject(callOrIdentity(headers)),
+        ...HeadersInitToPlainObject(requestOptions.requestHeaders)
+      },
+      fetch: fetch2,
+      method,
+      fetchOptions,
+      middleware: requestMiddleware
+    });
+    if (responseMiddleware) {
+      await responseMiddleware(response, {
+        operationName: analyzedDocument.operationName,
+        variables: requestOptions.variables,
+        url: this.url
+      });
+    }
+    if (response instanceof Error) {
+      throw response;
+    }
+    return response.data;
+  }
+  async batchRequests(documentsOrOptions, requestHeaders) {
+    const batchRequestOptions = parseBatchRequestArgs(documentsOrOptions, requestHeaders);
+    const { headers, excludeOperationName, ...fetchOptions } = this.requestConfig;
+    if (batchRequestOptions.signal !== undefined) {
+      fetchOptions.signal = batchRequestOptions.signal;
+    }
+    const analyzedDocuments = batchRequestOptions.documents.map(({ document: document2 }) => analyzeDocument(document2, excludeOperationName));
+    const expressions = analyzedDocuments.map(({ expression }) => expression);
+    const hasMutations = analyzedDocuments.some(({ isMutation }) => isMutation);
+    const variables = batchRequestOptions.documents.map(({ variables: variables2 }) => variables2);
+    const response = await runRequest({
+      url: this.url,
+      request: {
+        _tag: `Batch`,
+        operationName: undefined,
+        query: expressions,
+        hasMutations,
+        variables
+      },
+      headers: {
+        ...HeadersInitToPlainObject(callOrIdentity(headers)),
+        ...HeadersInitToPlainObject(batchRequestOptions.requestHeaders)
+      },
+      fetch: this.requestConfig.fetch ?? globalThis.fetch,
+      method: this.requestConfig.method || `POST`,
+      fetchOptions,
+      middleware: this.requestConfig.requestMiddleware
+    });
+    if (this.requestConfig.responseMiddleware) {
+      await this.requestConfig.responseMiddleware(response, {
+        operationName: undefined,
+        variables,
+        url: this.url
+      });
+    }
+    if (response instanceof Error) {
+      throw response;
+    }
+    return response.data;
+  }
+  setHeaders(headers) {
+    this.requestConfig.headers = headers;
+    return this;
+  }
+  setHeader(key2, value2) {
+    const { headers } = this.requestConfig;
+    if (headers) {
+      headers[key2] = value2;
+    } else {
+      this.requestConfig.headers = { [key2]: value2 };
+    }
+    return this;
+  }
+  setEndpoint(value2) {
+    this.url = value2;
+    return this;
+  }
+}
+
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/functions/request.js
+var parseRequestArgs = (documentOrOptions, variables, requestHeaders) => {
+  return documentOrOptions.document ? documentOrOptions : {
+    document: documentOrOptions,
+    variables,
+    requestHeaders,
+    signal: undefined
+  };
+};
+// ../../node_modules/.pnpm/graphql-request@7.3.1_graphql@16.12.0/node_modules/graphql-request/build/legacy/functions/gql.js
+var gql = (chunks, ...variables) => {
+  return chunks.reduce((acc, chunk, index) => `${acc}${chunk}${index in variables ? String(variables[index]) : ``}`, ``);
+};
+// ../../packages/common/dist/utils/vetra-gql.js
+async function getVetraDocuments(graphqlEndpoint, driveId) {
+  const client = new GraphQLClient(graphqlEndpoint, {
+    fetch
+  });
+  const query = gql`
+    query GetDocuments($driveId: String!) {
+      VetraPackage {
+        getDocuments(driveId: $driveId) {
+          id
+          state {
+            githubUrl
+          }
+        }
+      }
+    }
+  `;
+  const response = await client.request(query, {
+    driveId
+  });
+  return response.VetraPackage.getDocuments.map((doc2) => ({
+    id: doc2.id,
+    githubUrl: doc2.state.githubUrl
+  }));
+}
+async function createVetraDocument(graphqlEndpoint, driveId, name = "vetra-package") {
+  const client = new GraphQLClient(graphqlEndpoint, {
+    fetch
+  });
+  const mutation = gql`
+    mutation CreateDocument($driveId: String, $name: String) {
+      VetraPackage_createDocument(driveId: $driveId, name: $name)
+    }
+  `;
+  const response = await client.request(mutation, {
+    driveId,
+    name
+  });
+  return response.VetraPackage_createDocument;
+}
+
+// src/utils/validate-remote-drive.ts
+async function setupRemoteDrive(remoteDriveUrl) {
+  try {
+    const driveId = remoteDriveUrl.split("/").pop();
+    if (!remoteDriveUrl || remoteDriveUrl.trim() === "") {
+      console.error("❌ Remote drive URL is required");
+      return false;
+    }
+    const url4 = new URL(remoteDriveUrl);
+    const graphqlEndpoint = `${url4.protocol}//${url4.host}/graphql`;
+    let documents = await getVetraDocuments(graphqlEndpoint, driveId);
+    if (documents.length === 0) {
+      console.log("No vetra package document found in the provided drive, creating one...");
+      try {
+        await createVetraDocument(graphqlEndpoint, driveId, "vetra-package");
+        documents = await getVetraDocuments(graphqlEndpoint, driveId);
+        if (documents.length === 0) {
+          console.error("❌ Failed to create vetra package document in the remote drive");
+          return false;
+        }
+        console.log("✅ Vetra package document created successfully");
+      } catch (createError2) {
+        console.error("❌ Failed to create vetra package document:", createError2);
+        return false;
+      }
+    }
+    if (documents.length > 1) {
+      console.warn("⚠️  Multiple vetra package documents were found in the provided remote drive, this might be an error in your remote drive");
+    }
+    const hasGithubUrl = documents.some((doc2) => doc2.githubUrl);
+    if (hasGithubUrl) {
+      console.error("❌ The remote drive provided already has been configured with a github url, please use the checkout command instead: ph checkout --remote-drive <remote drive url>");
+      return false;
+    }
+    return true;
+  } catch (error49) {
+    console.error("❌ Unable to fetch remote drive info:", error49);
+    return false;
+  }
+}
+
+// src/commands/init.ts
 var initArgs = {
   namePositional: import_cmd_ts12.positional({
     type: import_cmd_ts12.optional(import_cmd_ts12.string),
@@ -693038,26 +693634,32 @@ var initArgs = {
     long: "remote-drive",
     short: "r",
     description: "Remote drive identifier."
-  })
+  }),
+  ...debugArgs
 };
 var init4 = import_cmd_ts12.command({
   name: "init",
   description: "Initialize a new project",
   args: initArgs,
-  handler: async ({
-    namePositional,
-    nameOption,
-    packageManager,
-    npm: npm2,
-    pnpm: pnpm2,
-    yarn: yarn2,
-    bun: bun2,
-    tag: tag2,
-    version: version3,
-    dev,
-    staging,
-    remoteDrive
-  }) => {
+  handler: async (args) => {
+    const {
+      namePositional,
+      nameOption,
+      packageManager,
+      npm: npm2,
+      pnpm: pnpm2,
+      yarn: yarn2,
+      bun: bun2,
+      tag: tag2,
+      version: version3,
+      dev,
+      staging,
+      remoteDrive,
+      debug
+    } = args;
+    if (debug) {
+      console.log({ args });
+    }
     let name = namePositional ?? nameOption;
     if (!name) {
       const { prompt } = import_enquirer2.default;
@@ -693075,15 +693677,18 @@ var init4 = import_cmd_ts12.command({
     if (!name) {
       throw new Error("You must provide a name for your project.");
     }
+    console.log("step 1 done");
     if (version3 !== undefined && !import_semver4.valid(import_semver4.clean(version3))) {
       throw new Error(`Invalid version: ${version3}`);
     }
+    console.log("step w done");
     handleMutuallyExclusiveOptions({
       tag: tag2,
       version: version3,
       dev,
       staging
     }, "versioning strategy");
+    console.log("step 3 done");
     handleMutuallyExclusiveOptions({
       npm: npm2,
       pnpm: pnpm2,
@@ -693091,6 +693696,7 @@ var init4 = import_cmd_ts12.command({
       bun: bun2,
       packageManager
     }, "package manager");
+    console.log("step 4 done");
     const parsedPackageManager = parsePackageManager({
       npm: npm2,
       pnpm: pnpm2,
@@ -693098,18 +693704,48 @@ var init4 = import_cmd_ts12.command({
       bun: bun2,
       packageManager
     }) ?? "npm";
+    console.log("step 5 done");
     const parsedTag = parseTag({
       tag: tag2,
       dev,
       staging
     });
-    return {
-      name,
-      version: version3,
-      remoteDrive,
-      packageManager: parsedPackageManager,
-      tag: parsedTag
-    };
+    try {
+      if (remoteDrive) {
+        console.log(source_default.blue(`
+⏳ Setting up remote drive...
+`));
+        await setupRemoteDrive(remoteDrive);
+        console.log(source_default.green(`
+✅ Remote drive set up.`));
+      }
+      console.log(source_default.bold(`
+\uD83D\uDE80 Initializing a new project...
+`));
+      await createProject({
+        ...args,
+        name,
+        packageManager: parsedPackageManager,
+        tag: parsedTag
+      });
+      if (remoteDrive) {
+        console.log();
+        console.log("To link your project to GitHub:");
+        console.log();
+        console.log("  1. Create a new repository on GitHub");
+        console.log(`  2. cd ${name}`);
+        console.log("  3. git add . && git commit -m 'Initial commit'");
+        console.log("  4. git remote add origin <your-github-url>");
+        console.log(`  5. git push -u origin main`);
+        console.log();
+      }
+    } catch (error49) {
+      console.error(`
+❌ Failed to initialize project: 
+`);
+      throw error49;
+    }
+    process.exit(0);
   }
 });
 
@@ -693119,7 +693755,11 @@ var setupGlobals = import_cmd_ts13.command({
   name: "setup-globals",
   description: "Initialize a new global project",
   args: initArgs,
-  handler: async ({ namePositional, nameOption, ...options8 }) => {
+  handler: async (args) => {
+    const { namePositional, nameOption, debug, ...options8 } = args;
+    if (debug) {
+      console.log({ args });
+    }
     const name = namePositional ?? nameOption;
     await createGlobalProject(name, options8);
     process.exit(0);
@@ -693139,7 +693779,7 @@ import path20 from "node:path";
 import fs13, { promises as fsPromises2 } from "node:fs";
 
 // ../../node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
-function isPlainObject3(value2) {
+function isPlainObject4(value2) {
   if (typeof value2 !== "object" || value2 === null) {
     return false;
   }
@@ -693149,7 +693789,7 @@ function isPlainObject3(value2) {
 
 // ../../node_modules/.pnpm/sort-keys@5.1.0/node_modules/sort-keys/index.js
 function sortKeys(object2, options8 = {}) {
-  if (!isPlainObject3(object2) && !Array.isArray(object2)) {
+  if (!isPlainObject4(object2) && !Array.isArray(object2)) {
     throw new TypeError("Expected a plain object or array");
   }
   const { deep, compare } = options8;
@@ -693165,7 +693805,7 @@ function sortKeys(object2, options8 = {}) {
       if (Array.isArray(item)) {
         return deepSortArray(item);
       }
-      if (isPlainObject3(item)) {
+      if (isPlainObject4(item)) {
         return _sortKeys(item);
       }
       return item;
@@ -693186,7 +693826,7 @@ function sortKeys(object2, options8 = {}) {
       if (deep && Array.isArray(value2)) {
         newValue = deepSortArray(value2);
       } else {
-        newValue = deep && isPlainObject3(value2) ? _sortKeys(value2) : value2;
+        newValue = deep && isPlainObject4(value2) ? _sortKeys(value2) : value2;
       }
       Object.defineProperty(result, key2, {
         ...Object.getOwnPropertyDescriptor(object3, key2),
@@ -693314,7 +693954,7 @@ var init5 = (function_, filePath, data, options8) => {
     sortKeys: false,
     ...options8
   };
-  if (options8.sortKeys && isPlainObject3(data)) {
+  if (options8.sortKeys && isPlainObject4(data)) {
     data = sortKeys(data, {
       deep: true,
       compare: typeof options8.sortKeys === "function" ? options8.sortKeys : undefined
@@ -693424,9 +694064,14 @@ var update = import_cmd_ts14.command({
       long: "skip-install",
       short: "s",
       description: "Skip running `install` with your package manager"
-    })
+    }),
+    ...debugArgs
   },
-  handler: async ({ skipInstall }) => {
+  handler: async (args) => {
+    const { skipInstall, debug } = args;
+    if (debug) {
+      console.log({ args });
+    }
     console.log(`
 ▶️ Updating Powerhouse dependencies...
 `);
@@ -693542,13 +694187,14 @@ var useLocal = import_cmd_ts15.command({
       long: "skip-install",
       short: "s",
       description: "Skip running `install` with `pnpm`"
-    })
+    }),
+    ...debugArgs
   },
-  handler: async ({
-    monorepoPathPositional,
-    monorepoPathOption,
-    skipInstall
-  }) => {
+  handler: async (args) => {
+    const { monorepoPathPositional, monorepoPathOption, skipInstall, debug } = args;
+    if (debug) {
+      console.log({ args });
+    }
     const monorepoPath = monorepoPathPositional ?? monorepoPathOption;
     if (!monorepoPath) {
       throw new Error("❌ Please provide the path to your local powerhouse monorepo.");
@@ -693665,9 +694311,14 @@ var use = import_cmd_ts16.command({
       long: "skip-install",
       short: "s",
       description: "Skip running `install` with your package manager"
-    })
+    }),
+    ...debugArgs
   },
-  handler: async ({ tagPositional, tagOption, version: version3, skipInstall }) => {
+  handler: async (args) => {
+    const { tagPositional, tagOption, version: version3, skipInstall, debug } = args;
+    if (debug) {
+      console.log({ args });
+    }
     const tag2 = tagPositional ?? tagOption;
     handleMutuallyExclusiveOptions({ tag: tag2, version: version3 }, "versioning strategy");
     if (!tag2 && !version3) {
@@ -693790,7 +694441,7 @@ async function main2() {
     await executePhCliCommand(command8);
     return;
   }
-  await import_cmd_ts18.run(ph2, process.argv.slice(2));
+  await import_cmd_ts18.run(ph2, args);
 }
 await main2().catch((e8) => {
   console.error(e8);