@catladder/cli 0.0.0-next-95928577 → 0.0.0-next-e7541a00

package/src/apps/catenv/writeEnvDTs.ts

@@ -1,4 +1,4 @@
-import { writeGeneratedFile, type Config } from "@catladder/pipeline";
+import type { CatenvContext } from "@catladder/pipeline";
 import { join } from "path";
 import { getEnvironment } from "../../config/getProjectConfig";
 import { getGitRoot } from "../../utils/projects";
@@ -8,13 +8,18 @@ import {
   getCurrentComponentAndEnvFromChoice,
 } from "./utils";
 
-export const writeDTsFiles = async (config: Config, choice?: Choice) => {
+export const writeDTsFiles = async (
+  context: CatenvContext,
+  choice?: Choice,
+) => {
   const { env, currentComponent } = await getCurrentComponentAndEnvFromChoice(
-    config,
+    context.config,
     choice,
   );
 
-  const componentsWithEnabledEnvDTsWrite = Object.entries(config.components)
+  const componentsWithEnabledEnvDTsWrite = Object.entries(
+    context.config.components,
+  )
     .filter(([, component]) => component?.envDTs ?? true)
     .map(([componentName]) => componentName);
 
@@ -29,9 +34,13 @@ export const writeDTsFiles = async (config: Config, choice?: Choice) => {
     const envNames = await getEnvsForDTs(env, componentName);
     const envDTsContent = createEnvDTsContent(envNames);
 
-    const componentDir = getComponentFullPath(gitRoot, config, componentName);
+    const componentDir = getComponentFullPath(
+      gitRoot,
+      context.config,
+      componentName,
+    );
     const filePath = join(componentDir, "env.d.ts");
-    await writeGeneratedFile(filePath, envDTsContent, {
+    await context.fileWriter.writeGeneratedFile(filePath, envDTsContent, {
       commentChar: "//",
     });
   }

package/src/apps/cli/commands/project/commandConfigSecrets.ts

@@ -1,8 +1,7 @@
 import { getSecretVarName } from "@catladder/pipeline";
 import { stripIndents } from "common-tags";
-import { difference } from "lodash";
-import type { CommandInstance } from "vorpal";
-import type Vorpal from "vorpal";
+import { difference } from "lodash-es";
+import type { IO } from "../../../../core/types";
 import {
   getAllComponentsWithAllEnvsHierarchical,
   getEnvironment,
@@ -14,7 +13,6 @@ import {
 import { editAsFile } from "../../../../utils/editAsFile";
 import { upsertAllVariables } from "../../../../utils/gitlab";
 import { delay } from "../../../../utils/promise";
-import { allEnvsAndAllComponents } from "./utils/autocompletions";
 
 type Vars = {
   [env: string]: {
@@ -62,7 +60,7 @@ const getSecretEnvVarKeysToConfigure = async (
     .map((k) => k.key);
 };
 const getEnvVarsToEdit = async (
-  instance: CommandInstance,
+  instance: IO,
   env: string,
   componentName: string,
 ) => {
@@ -92,7 +90,7 @@ const getEnvVarsToEdit = async (
   );
 };
 const doItFor = async (
-  instance: CommandInstance,
+  instance: IO,
   envAndComponents: {
     [componentName: string]: string[];
   },
@@ -161,12 +159,7 @@ const doItFor = async (
           }
 
           await delay(1000);
-          const { shouldContinue } = await instance.prompt({
-            default: true,
-            message: "Try again? 🤔",
-            name: "shouldContinue",
-            type: "confirm",
-          });
+          const shouldContinue = await instance.confirm("Try again? 🤔");
 
           if (!shouldContinue) {
             throw new Error("abort");
@@ -197,40 +190,22 @@ const doItFor = async (
   instance.log("");
 };
 
-export const projectConfigSecrets = async (
-  vorpal: CommandInstance,
-  envComponent?: string,
-) => {
+export const projectConfigSecrets = async (io: IO, envComponent?: string) => {
   if (!envComponent) {
     const allEnvAndcomponents = await getAllComponentsWithAllEnvsHierarchical();
-    await doItFor(vorpal, allEnvAndcomponents);
+    await doItFor(io, allEnvAndcomponents);
   } else {
     const { env, componentName } = parseChoice(envComponent);
 
     // componentName can be null. in this case, iterate over all  components
     if (!componentName) {
       const components = await getProjectComponents();
-      await doItFor(
-        vorpal,
-        Object.fromEntries(components.map((c) => [c, [env]])),
-      );
+      await doItFor(io, Object.fromEntries(components.map((c) => [c, [env]])));
     }
     if (componentName) {
-      await doItFor(vorpal, {
+      await doItFor(io, {
         [componentName]: [env],
       });
     }
   }
 };
-
-export default async (vorpal: Vorpal) => {
-  vorpal
-    .command(
-      "project-config-secrets [envComponent]",
-      "setup/update secrets stored in pass",
-    )
-    .autocomplete(await allEnvsAndAllComponents())
-    .action(async function ({ envComponent }) {
-      return await projectConfigSecrets(this, envComponent);
-    });
-};

package/src/apps/cli/commands/project/setup/index.ts

@@ -1,33 +1,30 @@
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 import { getAllPipelineContexts } from "../../../../../config/getProjectConfig";
-import { projectConfigSecrets } from "../commandConfigSecrets";
 import { setupAccessTokens } from "./setupAccessTokens";
 import { setupContext } from "./setupContext";
 import { setupTopic } from "./setupTopic";
+import { setupAgents } from "./setupAgents";
+import { logSection } from "./logSection";
 
-export const setupProject = async (instance: CommandInstance) => {
-  const allContext = await getAllPipelineContexts();
+export const setupProject = async (
+  instance: IO,
+  onlyComponents?: string | string[],
+) => {
+  const allContext = await getAllPipelineContexts(onlyComponents);
+  instance.log("will setup those contexts:");
+  allContext.forEach((context) => {
+    instance.log(` - ${context.name}:${context.env}`);
+  });
 
+  await logSection(instance, "base setup", async () => {
+    await setupAccessTokens(instance);
+    await setupTopic(instance);
+    await setupAgents(instance);
+  });
   for (const context of allContext) {
     await setupContext(instance, context);
   }
-  await setupAccessTokens(instance);
-  await setupTopic(instance);
-  instance.log("");
-  const { configSecrets } = await instance.prompt({
-    default: true,
-    message: "Before deployments work, you need to config secrets. Do it now?",
-    name: "configSecrets",
-    type: "confirm",
-  });
-  instance.log("");
-  if (configSecrets) {
-    await projectConfigSecrets(instance);
-  } else {
-    instance.log(
-      "👆 don't forget to config secret using `project-config-secrets`",
-    );
-  }
+
   instance.log("");
   instance.log("gitlab is ready! 🥂");
   instance.log("\n");

package/src/apps/cli/commands/project/setup/logSection.ts

@@ -0,0 +1,22 @@
+import type { IO } from "../../../../../core/types";
+
+export const logSection = async (
+  instance: IO,
+  title: string,
+  work: () => Promise<void>,
+) => {
+  instance.log("");
+  instance.log(
+    "==================================================================================",
+  );
+  instance.log("🐱 🔧 " + title + "...");
+  instance.log("");
+  await work();
+  instance.log("");
+  instance.log("✅    " + title + " done!");
+  instance.log("");
+  instance.log(
+    "==================================================================================",
+  );
+  instance.log("");
+};

package/src/apps/cli/commands/project/setup/setupAccessTokens.ts

@@ -1,10 +1,10 @@
-import type { CommandInstance } from "vorpal";
-import dayjs from "dayjs";
+import type { IO } from "../../../../../core/types";
+import { add, format } from "date-fns";
 import { doGitlabRequest, getProjectInfo } from "../../../../../utils/gitlab";
 
 const TOKEN_NAME = "semantic-release";
 
-export const setupAccessTokens = async (instance: CommandInstance) => {
+export const setupAccessTokens = async (instance: IO) => {
   const { id: projectId } = await getProjectInfo(instance);
 
   const projectTokens = await doGitlabRequest(
@@ -15,10 +15,10 @@ export const setupAccessTokens = async (instance: CommandInstance) => {
     (t) => t.name === TOKEN_NAME && t.active === true,
   );
 
-  const expires_at = dayjs()
-    .add(1, "year")
-    .subtract(1, "day")
-    .format("YYYY-MM-DD");
+  const expires_at = format(
+    add(new Date(), { years: 1, days: -1 }),
+    "yyyy-MM-dd",
+  );
 
   const newToken = token
     ? await doGitlabRequest(

package/src/apps/cli/commands/project/setup/setupAgents.ts

@@ -0,0 +1,323 @@
+import type { IO } from "../../../../../core/types";
+import { doGitlabRequest, getProjectInfo } from "../../../../../utils/gitlab";
+import { getProjectConfig } from "../../../../../config/getProjectConfig";
+import { getGitRemoteHostAndPath } from "../../../../../git/gitProjectInformation";
+import { getMainBranch } from "../../../../../git";
+import type { AgentConfig } from "@catladder/pipeline";
+
+type TriggerToken = {
+  id: number;
+  description: string;
+  created_at: string;
+  last_used: string | null;
+  token: string;
+  updated_at: string;
+  owner: any;
+};
+
+type Webhook = {
+  id: number;
+  url: string;
+  name: string;
+  description: string;
+  project_id: number;
+  push_events: boolean;
+  push_events_branch_filter: string;
+  issues_events: boolean;
+  confidential_issues_events: boolean;
+  merge_requests_events: boolean;
+  tag_push_events: boolean;
+  note_events: boolean;
+  confidential_note_events: boolean;
+  job_events: boolean;
+  pipeline_events: boolean;
+  wiki_page_events: boolean;
+  deployment_events: boolean;
+  releases_events: boolean;
+  milestone_events: boolean;
+  feature_flag_events: boolean;
+  enable_ssl_verification: boolean;
+  repository_update_events: boolean;
+  alert_status: string;
+  disabled_until: string | null;
+  url_variables: any[];
+  created_at: string;
+  resource_access_token_events: boolean;
+  custom_webhook_template: string;
+  custom_headers: Array<{ key: string; value?: string }>;
+};
+
+type WebhookData = {
+  url: string;
+  name: string;
+  description: string;
+  issues_events: boolean;
+  confidential_issues_events: boolean;
+  merge_requests_events: boolean;
+  note_events: boolean;
+  confidential_note_events: boolean;
+  custom_webhook_template: string;
+};
+
+const listTriggerTokens = async (
+  instance: IO,
+  projectId: string,
+): Promise<TriggerToken[]> => {
+  return await doGitlabRequest(instance, `projects/${projectId}/triggers`);
+};
+
+const deleteTriggerToken = async (
+  instance: IO,
+  projectId: string,
+  triggerId: number,
+): Promise<void> => {
+  await doGitlabRequest(
+    instance,
+    `projects/${projectId}/triggers/${triggerId}`,
+    undefined,
+    "DELETE",
+  );
+};
+
+const createTriggerToken = async (
+  instance: IO,
+  projectId: string,
+  description: string,
+): Promise<TriggerToken> => {
+  return await doGitlabRequest(
+    instance,
+    `projects/${projectId}/triggers`,
+    { description },
+    "POST",
+  );
+};
+
+const listWebhooks = async (
+  instance: IO,
+  projectId: string,
+): Promise<Webhook[]> => {
+  return await doGitlabRequest(instance, `projects/${projectId}/hooks`);
+};
+
+const createWebhook = async (
+  instance: IO,
+  projectId: string,
+  webhookData: WebhookData,
+): Promise<Webhook> => {
+  return await doGitlabRequest(
+    instance,
+    `projects/${projectId}/hooks`,
+    webhookData,
+    "POST",
+  );
+};
+
+const updateWebhook = async (
+  instance: IO,
+  projectId: string,
+  hookId: number,
+  webhookData: WebhookData,
+): Promise<Webhook> => {
+  return await doGitlabRequest(
+    instance,
+    `projects/${projectId}/hooks/${hookId}`,
+    webhookData,
+    "PUT",
+  );
+};
+
+const setupAgentWebhook = async (
+  instance: IO,
+  projectId: string,
+  agentName: string,
+  triggerToken: string,
+): Promise<Webhook> => {
+  const webhookName = `cl_agent_${agentName}_webhook`;
+  const { gitRemoteHost } = await getGitRemoteHostAndPath();
+  const mainBranch = await getMainBranch();
+  const webhookUrl = `https://${gitRemoteHost}/api/v4/projects/${projectId}/ref/${mainBranch}/trigger/pipeline?token=${triggerToken}`;
+
+  instance.log(`Setting up webhook for agent: ${agentName}`);
+
+  // List existing webhooks
+  const existingWebhooks = await listWebhooks(instance, projectId);
+
+  // Find existing webhook by name
+  const existingWebhook = existingWebhooks.find(
+    (webhook) => webhook.name === webhookName,
+  );
+
+  // Custom webhook template from the user's specification
+  const customWebhookTemplate = JSON.stringify({
+    variables: {
+      ASSIGNEE_USER_ID: "{{object_attributes.assignee_id}}",
+      OBJECT_DESCRIPTION: "{{object_attributes.description}}",
+    },
+    payload: {
+      object_kind: "{{object_kind}}",
+      event_type: "{{event_type}}",
+      user_id: "{{user.id}}",
+      user_name: "{{user.name}}",
+      user_username: "{{user.username}}",
+      user_avatar_url: "{{user.avatar_url}}",
+      user_email: "{{user.email}}",
+      project_id: "{{project.id}}",
+      project_name: "{{project.name}}",
+      project_web_url: "{{project.web_url}}",
+      project_namespace: "{{project.namespace}}",
+      project_path_with_namespace: "{{project.path_with_namespace}}",
+      object_attributes_id: "{{object_attributes.id}}",
+      object_attributes_iid: "{{object_attributes.iid}}",
+      object_attributes_title: "{{object_attributes.title}}",
+      object_attributes_description: "{{object_attributes.description}}",
+      object_attributes_state: "{{object_attributes.state}}",
+      object_attributes_created_at: "{{object_attributes.created_at}}",
+      object_attributes_updated_at: "{{object_attributes.updated_at}}",
+      object_attributes_url: "{{object_attributes.url}}",
+      object_attributes_action: "{{object_attributes.action}}",
+      object_attributes_noteable_type: "{{object_attributes.noteable_type}}",
+      merge_request_id: "{{merge_request.id}}",
+      merge_request_iid: "{{merge_request.iid}}",
+      merge_request_title: "{{merge_request.title}}",
+      merge_request_source_branch: "{{merge_request.source_branch}}",
+      merge_request_time_estimate: "{{merge_request.time_estimate}}",
+      merge_request_description: "{{merge_request.description}}",
+      merge_request_merge_status: "{{merge_request.merge_status}}",
+      merge_request_last_commit_title: "{{merge_request.last_commit.title}}",
+      merge_request_last_commit_message:
+        "{{merge_request.last_commit.message}}",
+      merge_request_last_commit_author_name:
+        "{{merge_request.last_commit.author.name}}",
+      merge_request_last_commit_author_email:
+        "{{merge_request.last_commit.author.email}}",
+    },
+  });
+
+  const webhookData: WebhookData = {
+    url: webhookUrl,
+    name: webhookName,
+    description: `Agent webhook for ${agentName} - triggers pipeline with custom payload`,
+    issues_events: true,
+    confidential_issues_events: false,
+    merge_requests_events: false,
+    note_events: true,
+    confidential_note_events: false,
+    custom_webhook_template: customWebhookTemplate,
+  };
+
+  let webhook: Webhook;
+
+  if (existingWebhook) {
+    instance.log(
+      `Updating existing webhook: ${webhookName} (ID: ${existingWebhook.id})`,
+    );
+    webhook = await updateWebhook(
+      instance,
+      projectId,
+      existingWebhook.id,
+      webhookData,
+    );
+    instance.log(`✅ Updated webhook: ${webhook.name}`);
+  } else {
+    instance.log(`Creating new webhook: ${webhookName}`);
+    webhook = await createWebhook(instance, projectId, webhookData);
+    instance.log(`✅ Created webhook: ${webhook.name}`);
+  }
+
+  instance.log(`   Webhook ID: ${webhook.id}`);
+  instance.log(`   Webhook URL: ${webhook.url}`);
+
+  return webhook;
+};
+
+const setupAgentTriggerToken = async (
+  instance: IO,
+  projectId: string,
+  agentName: string,
+): Promise<TriggerToken> => {
+  const tokenName = `cl_agent_${agentName}`;
+
+  instance.log(`Setting up trigger token for agent: ${agentName}`);
+
+  // List existing trigger tokens
+  const existingTokens = await listTriggerTokens(instance, projectId);
+
+  // Find and delete existing cl_agent_<agentName> tokens
+  const existingAgentTokens = existingTokens.filter((token) =>
+    token.description.startsWith(`cl_agent_${agentName}`),
+  );
+
+  for (const token of existingAgentTokens) {
+    instance.log(
+      `Deleting existing trigger token: ${token.description} (ID: ${token.id})`,
+    );
+    await deleteTriggerToken(instance, projectId, token.id);
+  }
+
+  // Create new trigger token
+  const description = `${tokenName} - Agent trigger token for ${agentName}`;
+  const newToken = await createTriggerToken(instance, projectId, description);
+
+  instance.log(`✅ Created new trigger token: ${newToken.description}`);
+  instance.log(`   Token ID: ${newToken.id}`);
+  instance.log(`   Token: ${newToken.token}`);
+
+  return newToken;
+};
+
+const setupAgent = async (
+  instance: IO,
+  agentName: string,
+  agentConfig: AgentConfig,
+) => {
+  const { id: projectId } = await getProjectInfo(instance);
+
+  instance.log(`🤖 Setting up agent: ${agentName}`);
+
+  // Setup trigger token for this agent
+  const triggerToken = await setupAgentTriggerToken(
+    instance,
+    projectId,
+    agentName,
+  );
+
+  // Setup webhook for this agent
+  await setupAgentWebhook(instance, projectId, agentName, triggerToken.token);
+
+  instance.log(`✅ Agent ${agentName} setup complete!`);
+};
+
+export const setupAgents = async (instance: IO) => {
+  const config = await getProjectConfig();
+
+  instance.log("");
+  instance.log("🤖 Setting up agents...");
+
+  const agents = config.agents ?? {};
+  const agentEntries = Object.entries(agents);
+
+  if (agentEntries.length === 0) {
+    instance.log("No agents configured in project config");
+    return;
+  }
+
+  for (const [agentName, agentConfig] of agentEntries) {
+    if (agentConfig.type === "claude" && agentConfig) {
+      await setupAgent(instance, agentName, agentConfig);
+    }
+  }
+
+  instance.log("✅ All agents setup complete!");
+  instance.log("");
+  instance.log("🔧 Manual setup required:");
+  instance.log(
+    "Please configure these environment variables in GitLab CI/CD unless they are already set (by group or global):",
+  );
+  instance.log("   Go to Settings > CI/CD > Variables and add:");
+  instance.log(
+    "   - CLAUDE_CODE_OAUTH_TOKEN or ANTHROPIC_API_KEY (your Anthropic API key, mark as Protected & Masked)",
+  );
+  instance.log(
+    "   - AGENT_GITLAB_PERSONAL_ACCESS_TOKEN (token from agent.claude user, mark as Protected & Masked)",
+  );
+};

package/src/apps/cli/commands/project/setup/setupCloudRun.ts

@@ -5,7 +5,7 @@ import {
   isOfDeployType,
 } from "@catladder/pipeline";
 
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 import { upsertGcloudArtifactsRegistry } from "../../../../../gcloud/artifactsRegistry";
 import { getCloudRunDomainSuffix } from "../../../../../gcloud/cloudRun/getCloudRunDomainSuffix";
 import { enableGCloudServices } from "../../../../../gcloud/enableServices";
@@ -13,7 +13,7 @@ import { upsertGcloudServiceAccountAndSaveSecret } from "../../../../../gcloud/s
 import { upsertAllVariables } from "../../../../../utils/gitlab";
 
 export const setupCloudRun = async (
-  instance: CommandInstance,
+  instance: IO,
   context: ComponentContext,
 ) => {
   if (!isOfDeployType(context.deploy?.config, "google-cloudrun")) {

package/src/apps/cli/commands/project/setup/setupContext.ts

@@ -1,32 +1,24 @@
 import type { ComponentContext } from "@catladder/pipeline";
 import { isOfDeployType } from "@catladder/pipeline";
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 import { setupCloudRun } from "./setupCloudRun";
 
 import { setupKubernetes } from "./setupKubernetes";
+import { logSection } from "./logSection";
 
-export const setupContext = async (
-  instance: CommandInstance,
-  context: ComponentContext,
-) => {
-  instance.log("");
-  instance.log(
-    "==================================================================================",
-  );
-
-  instance.log("🐱 🔧 setting up " + context.env + ":" + context.name + "...");
-  instance.log("");
-  if (isOfDeployType(context.deploy?.config, "google-cloudrun")) {
-    await setupCloudRun(instance, context);
-  }
-
-  const deployConfig = context.deploy?.config;
-  if (isOfDeployType(deployConfig, "kubernetes")) {
-    await setupKubernetes(instance, context);
-  }
+export const setupContext = async (instance: IO, context: ComponentContext) => {
+  await logSection(
+    instance,
+    "setting up " + context.env + ":" + context.name,
+    async () => {
+      if (isOfDeployType(context.deploy?.config, "google-cloudrun")) {
+        await setupCloudRun(instance, context);
+      }
 
-  instance.log("");
-  instance.log("✅ " + context.env + ":" + context.name + " done!");
-
-  instance.log("");
+      const deployConfig = context.deploy?.config;
+      if (isOfDeployType(deployConfig, "kubernetes")) {
+        await setupKubernetes(instance, context);
+      }
+    },
+  );
 };

package/src/apps/cli/commands/project/setup/setupKubernetes.ts

@@ -3,7 +3,7 @@ import {
   getFullKubernetesClusterName,
   isOfDeployType,
 } from "@catladder/pipeline";
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 import { exec } from "child-process-promise";
 import { connectToCluster } from "../../../../../utils/cluster";
 import {
@@ -14,7 +14,7 @@ import {
 import ensureNamespace from "../utils/ensureNamespace";
 
 export const setupKubernetes = async (
-  instance: CommandInstance,
+  instance: IO,
   context: ComponentContext,
 ) => {
   const deployConfig = context.deploy?.config;

package/src/apps/cli/commands/project/setup/setupTopic.ts

@@ -1,9 +1,9 @@
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 import { doGitlabRequest, getProjectInfo } from "../../../../../utils/gitlab";
 
 const catladderTopic = "catladder";
 
-export const setupTopic = async (instance: CommandInstance) => {
+export const setupTopic = async (instance: IO) => {
   const { id: projectId } = await getProjectInfo(instance);
 
   const { topics } = await doGitlabRequest(instance, `projects/${projectId}`);

package/src/apps/cli/commands/project/utils/autocompletions.ts

@@ -12,6 +12,15 @@ export const allEnvs = async () => {
   return getAllEnvsInAllComponents(config);
 };
 
+export const allComponents = async () => {
+  const config = await getProjectConfig();
+  if (!config) {
+    return [];
+  }
+
+  return Object.keys(config.components);
+};
+
 export const envAndComponents = async () => {
   const allEnvAndcomponents = await getAllComponentsWithAllEnvsFlat();