@effect-app/cli 1.26.4 → 1.26.5

package/src/gist.ts

@@ -17,6 +17,7 @@ import { RunCommandService } from "./os-command.js"
 export class GistEntry extends Schema.Class<GistEntry>("GistEntry")({
   description: Schema.String,
   public: Schema.Boolean,
+  company: Schema.String,
   files: Schema.Array(Schema.String)
 }) {}
 
@@ -96,16 +97,26 @@ export class GistEntryDecoded extends GistEntry.transformOrFail<GistEntryDecoded
 }) {}
 
 export class GistYAML extends Schema.Class<GistYAML>("GistYAML")({
-  gists: Schema.Record({
-    key: Schema.String,
-    value: GistEntryDecoded
-  }),
+  gists: Schema
+    .Record({
+      key: Schema.String,
+      value: GistEntryDecoded
+    })
+    .pipe(Schema.optionalWith({
+      default: () => ({}),
+      nullable: true,
+      exact: true
+    })),
   settings: Schema.Struct({
     token_env: Schema.String,
     base_directory: Schema.String
   })
 }) {}
 
+/**
+ * Cache entry representing a gist mapping.
+ * Each entry contains the gist's human-readable name and GitHub ID.
+ */
 export class GistCacheEntry extends Schema.Class<GistCacheEntry>("GistCacheEntry")({
   name: Schema.String,
   id: Schema.String
@@ -115,14 +126,16 @@ export const GistCacheEntries = Schema.Array(GistCacheEntry)
 export interface GistCacheEntries extends Schema.Schema.Type<typeof GistCacheEntries> {}
 
 /**
- * Gist cache mapping YAML configuration names to GitHub gist IDs.
+ * Gist cache mapping YAML configuration names to GitHub gist IDs with company awareness.
  *
  * Since GitHub gists don't have user-defined names, we maintain a cache
  * that maps the human-readable names from our YAML config to actual gist IDs.
+ * Each cache entry is associated with a company, enabling multi-tenant operations.
  * This allows us to:
  * - Update existing gists instead of creating duplicates
  * - Clean up obsolete entries when gists are removed from config
  * - Persist the name->ID mapping across CLI runs
+ * - Isolate gist operations by company context
  *
  * The cache itself is stored as a secret GitHub gist for persistence.
  */
@@ -130,9 +143,12 @@ export class GistCache {
   entries: GistCacheEntries
   gist_id: string
 
-  constructor({ entries, gist_id }: { entries: GistCacheEntries; gist_id: string }) {
+  company: string
+
+  constructor({ company, entries, gist_id }: { entries: GistCacheEntries; gist_id: string; company: string }) {
     this.entries = entries
     this.gist_id = gist_id
+    this.company = company
   }
 }
 
@@ -141,11 +157,16 @@ export class GistCache {
 // Errors
 //
 class GistCacheNotFound extends Data.TaggedError("GistCacheNotFound")<{
-  readonly reason: string
+  readonly message: string
+}> {}
+
+class GistCacheOfCompanyNotFound extends Data.TaggedError("GistCacheOfCompanyNotFound")<{
+  readonly message: string
+  readonly cache_gist_id: string
 }> {}
 
 class GistYAMLError extends Data.TaggedError("GistYAMLError")<{
-  readonly reason: string
+  readonly message: string
 }> {}
 
 //
@@ -153,6 +174,7 @@ class GistYAMLError extends Data.TaggedError("GistYAMLError")<{
 // Services
 //
 
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
 class GHGistService extends Effect.Service<GHGistService>()("GHGistService", {
   dependencies: [RunCommandService.Default],
   effect: Effect.gen(function*() {
@@ -184,9 +206,15 @@ class GHGistService extends Effect.Service<GHGistService>()("GHGistService", {
       return gist_id && gist_id.length > 0 ? Option.some(gist_id) : Option.none()
     }
 
-    const loadGistCache = Effect
+    const loadGistCache: (
+      company: string,
+      rec?: { recCache?: boolean; recCacheCompany?: boolean }
+    ) => Effect.Effect<GistCache, GistCacheOfCompanyNotFound, never> = Effect
       .fn("effa-cli.gist.loadGistCache")(
-        function*() {
+        function*(
+          company: string,
+          { recCache = false, recCacheCompany = false } = { recCache: false, recCacheCompany: false }
+        ) {
           // search for existing cache gist
           const output = yield* runGetStringSuppressed(`gh gist list --filter "${CACHE_GIST_DESCRIPTION}"`)
             .pipe(Effect.orElse(() => Effect.succeed("")))
@@ -196,59 +224,81 @@ class GHGistService extends Effect.Service<GHGistService>()("GHGistService", {
           // extract first gist ID (should be our cache gist)
           const firstLine = lines[0]
           if (!firstLine) {
-            return yield* new GistCacheNotFound({ reason: "Empty gist list output" })
+            return yield* new GistCacheNotFound({ message: "Empty gist list output" })
           }
 
           const parts = firstLine.split(/\s+/)
           const gist_id = parts[0]?.trim()
 
           if (!gist_id) {
-            return yield* new GistCacheNotFound({ reason: "No gist ID found in output" })
+            if (recCache) {
+              return yield* Effect.dieMessage("Failed to create or locate cache gist after creation attempt")
+            }
+            return yield* new GistCacheNotFound({ message: "No gist ID found in output" })
           } else {
             yield* Effect.logInfo(`Found existing cache gist with ID ${gist_id}`)
           }
 
-          // read cache gist content
-          const cacheContent = yield* runGetStringSuppressed(`gh gist view ${gist_id}`)
-            .pipe(Effect.orElse(() => Effect.succeed("")))
-
-          const entries = yield* pipe(
-            cacheContent.split(CACHE_GIST_DESCRIPTION)[1]?.trim(),
-            pipe(Schema.parseJson(GistCacheEntries), Schema.decodeUnknown),
-            Effect.orElse(() => new GistCacheNotFound({ reason: "Failed to parse cache JSON" }))
+          // read company-specific cache file
+          const filesInCache = yield* runGetStringSuppressed(`gh gist view ${gist_id} --files`).pipe(
+            Effect.map((files) =>
+              files
+                .trim()
+                .split("\n")
+                .map((f) => f.trim())
+            )
           )
 
-          return { entries, gist_id }
-        },
-        Effect.catchTag("GistCacheNotFound", () =>
-          Effect.gen(function*() {
-            // cache doesn't exist, create it
-            yield* Effect.logInfo("Cache gist not found, creating new cache...")
-
-            const cacheJson = yield* pipe(
-              [],
-              pipe(Schema.parseJson(GistCacheEntries), Schema.encodeUnknown),
-              // cannot recover from parse errors in any case, better to die here instead of cluttering the signature
+          if (!filesInCache.includes(`${company}.json`)) {
+            if (recCacheCompany) {
+              return yield* Effect.dieMessage(
+                `Failed to create or locate cache entry for company ${company} after creation attempt`
+              )
+            }
+            return yield* new GistCacheOfCompanyNotFound({
+              message: `Cache gist not found of company ${company}`,
+              cache_gist_id: gist_id
+            })
+          } else {
+            const cacheContent = yield* runGetStringSuppressed(`gh gist view ${gist_id} -f "${company}.json"`)
+
+            const entries = yield* pipe(
+              cacheContent,
+              pipe(Schema.parseJson(GistCacheEntries), Schema.decodeUnknown),
               Effect.orDie
             )
 
-            const gistUrl = yield* runGetStringSuppressed(
-              `echo '${cacheJson}' | gh gist create --desc="${CACHE_GIST_DESCRIPTION}" -`
-            )
+            return new GistCache({ entries, gist_id, company })
+          }
+        },
+        (_, company) =>
+          _.pipe(
+            Effect.catchTag("GistCacheNotFound", () =>
+              Effect.gen(function*() {
+                yield* Effect.logInfo("Cache gist not found, creating new cache...")
+
+                yield* runGetStringSuppressed(
+                  `echo "do_not_delete" | gh gist create --desc="${CACHE_GIST_DESCRIPTION}" -f effa-gist.cache -`
+                )
 
-            const gist_id = yield* pipe(
-              gistUrl,
-              extractGistIdFromUrl,
-              Option.match({
-                onNone: () => Effect.dieMessage(`Could not extract cache's gist ID from URL: ${gistUrl}`),
-                onSome: (id) =>
-                  Effect.succeed(id).pipe(Effect.tap(Effect.logInfo(`Created new cache gist with ID ${id}`)))
-              })
-            )
+                // retry loading the cache after creating it
+                return yield* loadGistCache(company, { recCache: true })
+              }))
+          ),
+        (_, company) =>
+          _.pipe(
+            Effect.catchTag("GistCacheOfCompanyNotFound", (e) =>
+              Effect.gen(function*() {
+                yield* Effect.logInfo(`Cache for company ${company} not found, creating company-specific cache file...`)
+
+                yield* runGetStringSuppressed(
+                  `echo "[]" | gh gist edit ${e.cache_gist_id} -a ${company}.json -`
+                )
 
-            return { entries: [], gist_id }
-          })),
-        Effect.map(({ entries, gist_id }) => new GistCache({ entries, gist_id }))
+                // retry loading the cache after creating it
+                return yield* loadGistCache(company, { recCacheCompany: true })
+              }))
+          )
       )
 
     const saveGistCache = Effect.fn("effa-cli.gist.saveGistCache")(
@@ -260,17 +310,22 @@ class GHGistService extends Effect.Service<GHGistService>()("GHGistService", {
           Effect.orDie
         )
 
-        yield* runGetExitCodeSuppressed(`echo '${cacheJson}' | gh gist edit ${cache.gist_id} -`)
+        yield* runGetExitCodeSuppressed(
+          `echo '${cacheJson}' | gh gist edit ${cache.gist_id} -f ${cache.company}.json -`
+        )
       }
     )
 
     const createGistWithFiles = Effect.fn("GHGistService.createGistWithFiles")(
-      function*({ cache, description, files, gist_name, is_public }: {
+      function*({ description, env, files, gist_name, is_public }: {
         gist_name: string
         description: string
-        files: string[]
+        files: {
+          path: string
+          name: string
+        }[]
         is_public: boolean
-        cache: GistCache
+        env: string
       }) {
         yield* Effect.logInfo(`Creating gist ${gist_name} with ${files.length} file(s)`)
 
@@ -280,7 +335,7 @@ class GHGistService extends Effect.Service<GHGistService>()("GHGistService", {
           "create",
           `--desc="${description}"`,
           is_public ? "--public" : "",
-          ...files.map((filePath) => `"${filePath}"`)
+          ...files.map((file) => `"${file.path}"`)
         ]
           .filter((x) => !!x)
           .join(" ")
@@ -289,7 +344,7 @@ class GHGistService extends Effect.Service<GHGistService>()("GHGistService", {
         const gistUrl = yield* runGetStringSuppressed(ghCommand)
 
         // extract ID from URL
-        return yield* pipe(
+        const gistNameId = yield* pipe(
           gistUrl,
           extractGistIdFromUrl,
           Option.match({
@@ -297,57 +352,94 @@ class GHGistService extends Effect.Service<GHGistService>()("GHGistService", {
             onSome: (id) =>
               Effect
                 .succeed(
-                  new GistCache({
-                    gist_id: cache.gist_id,
-                    entries: [...cache.entries, { name: gist_name, id }]
-                  })
+                  { name: gist_name, id }
                 )
                 .pipe(Effect.tap(Effect.logInfo(`Created gist with ID ${id}`)))
           })
         )
+
+        // rename all files to include environment prefix for multi-environment support
+        for (const file of files) {
+          const originalName = file.name
+          const name_with_env = `${env}.${originalName}`
+          const ghRenameCommand = [
+            "gh",
+            "gist",
+            "rename",
+            gistNameId.id,
+            originalName,
+            name_with_env
+          ]
+            .join(" ")
+
+          yield* Effect.logInfo(`Renaming file ${originalName} to ${name_with_env} in gist ${gist_name}`)
+          yield* runGetStringSuppressed(ghRenameCommand)
+        }
+
+        return gistNameId
       }
     )
 
     const getGistFileNames = Effect.fn("getGistFileNames")(
-      function*({ gist_id, gist_name }: {
+      function*({ env, gist_id, gist_name }: {
         gist_id: string
         gist_name: string
+        env: string
       }) {
         yield* Effect.logInfo(`Retrieving file names from gist ${gist_name} with ID ${gist_id}`)
         const output = yield* runGetStringSuppressed(`gh gist view ${gist_id} --files`)
-        return output
-          .trim()
-          .split("\n")
-          .filter((line: string) => line.trim())
+
+        // filter file names by environment prefix and remove the prefix
+        // files in gists are prefixed with "env." to support multiple environments
+        return Array.filterMap(
+          output
+            .trim()
+            .split("\n"),
+          (fn) => {
+            const fnTrimmed = fn.trim()
+            if (!fnTrimmed.startsWith(env + ".")) {
+              return Option.none()
+            }
+            return Option.some(
+              fnTrimmed.substring(env.length + 1) // remove env prefix and dot
+            )
+          }
+        )
       }
     )
 
     const removeFileFromGist = Effect.fn("removeFileFromGist")(
-      function*({ file_name, gist_id, gist_name }: {
+      function*({ env, file_name, gist_id, gist_name }: {
         gist_id: string
         gist_name: string
         file_name: string
+        env: string
       }) {
-        yield* Effect.logInfo(`Removing file ${file_name} from gist ${gist_name}`)
-        return yield* runGetExitCodeSuppressed(`gh gist edit ${gist_id} --remove "${file_name}"`)
+        const name_with_env = `${env}.${file_name}`
+        yield* Effect.logInfo(`Removing file ${name_with_env} from gist ${gist_name}`)
+        return yield* runGetExitCodeSuppressed(`gh gist edit ${gist_id} --remove "${name_with_env}"`)
       }
     )
 
     const updateFileOfGist = Effect.fn("updateFileOfGist")(
-      function*({ file_name, file_path, gist_id, gist_name }: {
+      function*({ env, file_name, file_path, gist_id, gist_name }: {
         gist_id: string
         gist_name: string
         file_name: string
         file_path: string
+        env: string
       }) {
-        yield* Effect.logInfo(`Updating file ${file_name} located at ${file_path} of gist ${gist_name}`)
+        const name_with_env = `${env}.${file_name}`
+        yield* Effect.logInfo(`Updating file ${name_with_env} located at ${file_path} of gist ${gist_name}`)
+
+        // it seems this does not require renaming the file
         const editCommand = [
           "gh",
           "gist",
           "edit",
           gist_id,
           "-f",
-          file_name,
+          name_with_env,
           `"${file_path}"`
         ]
           .join(" ")
@@ -357,23 +449,47 @@ class GHGistService extends Effect.Service<GHGistService>()("GHGistService", {
     )
 
     const addFileToGist = Effect.fn("addFileToGist")(
-      function*({ file_path, gist_id, gist_name }: {
+      function*({ env, file, gist_id, gist_name }: {
         gist_id: string
         gist_name: string
-        file_path: string
+        file: {
+          path: string
+          name: string
+        }
+        env: string
       }) {
-        yield* Effect.logInfo(`Adding file ${file_path} to gist ${gist_name}`)
+        yield* Effect.logInfo(`Adding file ${file.path} to gist ${gist_name}`)
         const editCommand = [
           "gh",
           "gist",
           "edit",
           gist_id,
           "-a",
-          `"${file_path}"`
+          `"${file.path}"`
         ]
           .join(" ")
 
-        return yield* runGetExitCodeSuppressed(editCommand)
+        yield* runGetExitCodeSuppressed(editCommand)
+
+        const renameCommand = [
+          "gh",
+          "gist",
+          "rename",
+          gist_id,
+          file.name,
+          `${env}.${file.name}`
+        ]
+          .join(" ")
+
+        yield* Effect.logInfo(`Renaming file ${file.name} to ${env}.${file.name} in gist ${gist_name}`)
+        return yield* runGetExitCodeSuppressed(renameCommand)
+      }
+    )
+
+    const deleteGist = Effect.fn("deleteGist")(
+      function*({ gist_id, gist_name }: { gist_id: string; gist_name: string }) {
+        yield* Effect.logInfo(`Deleting gist ${gist_name} with ID ${gist_id}`)
+        return yield* runGetExitCodeSuppressed(`gh gist delete ${gist_id}`)
       }
     )
 
@@ -419,55 +535,72 @@ class GHGistService extends Effect.Service<GHGistService>()("GHGistService", {
       saveGistCache,
 
       /**
-       * Creates a new GitHub gist with the specified files and updates the local cache.
-       * Generates a GitHub CLI command to create the gist and extracts the resulting gist ID.
+       * Creates a new GitHub gist with the specified files and renames them with environment prefixes.
+       * Generates a GitHub CLI command to create the gist, extracts the resulting gist ID,
+       * and renames all files with environment prefixes for multi-environment support.
        *
-       * @param cache - The current GistCache instance
-       * @param name - The human-readable name for this gist (used in cache mapping)
+       * @param gist_name - The human-readable name for this gist (used in cache mapping)
        * @param description - The description for the GitHub gist
-       * @param files - Array of file paths to include in the gist
+       * @param files - Array of file objects with path and name properties to include in the gist
        * @param is_public - Whether the gist should be public or private
-       * @returns An Effect that yields an updated GistCache with the new gist entry
+       * @param env - Environment prefix to prepend to file names (e.g., "local-dev", "prod")
+       * @returns An Effect that yields a gist entry object with name and id properties
        */
       createGistWithFiles,
 
       /**
-       * Retrieves file names from a GitHub gist.
-       * Fetches the list of files contained in the specified gist.
+       * Retrieves file names from a GitHub gist, filtered by environment prefix.
+       * Fetches the list of files contained in the specified gist and returns only
+       * those that match the current environment, with the environment prefix removed.
        *
        * @param gist_id - The GitHub gist ID to retrieve file names from
        * @param gist_name - The human-readable name of the gist (for logging purposes)
-       * @returns An Effect that yields an array of file names
+       * @param env - Environment prefix to filter files by (e.g., "local-dev", "prod")
+       * @returns An Effect that yields an array of file names with environment prefix removed
        */
       getGistFileNames,
 
       /**
        * Removes a file from a specified GitHub gist.
+       * The file name is automatically prefixed with the environment when removing.
        * @param gist_id - The ID of the gist to modify
        * @param gist_name - The human-readable name of the gist (for logging purposes)
-       * @param file_name - The name of the file to remove from the gist
+       * @param file_name - The base name of the file to remove (without environment prefix)
+       * @param env - Environment prefix that was used when the file was added
        * @returns An Effect that succeeds when the file is removed
        */
       removeFileFromGist,
 
       /**
        * Updates a file in a specified GitHub gist.
+       * The file name is automatically prefixed with the environment when updating.
        * @param gist_id - The ID of the gist to modify
        * @param gist_name - The human-readable name of the gist (for logging purposes)
-       * @param file_name - The name of the file to remove from the gist
+       * @param file_name - The base name of the file to update (without environment prefix)
        * @param file_path - The local path of the file to update in the gist
+       * @param env - Environment prefix that was used when the file was added
        * @returns An Effect that succeeds when the file is updated
        */
       updateFileOfGist,
 
       /**
        * Adds a new file to a specified GitHub gist.
+       * The file is automatically renamed with an environment prefix for multi-environment support.
        * @param gist_id - The ID of the gist to modify
        * @param gist_name - The human-readable name of the gist (for logging purposes)
-       * @param file_path - The local path of the file to add to the gist
-       * @returns An Effect that succeeds when the file is added
+       * @param file - The file object containing path and name properties
+       * @param env - Environment prefix to prepend to the file name
+       * @returns An Effect that succeeds when the file is added and renamed
+       */
+      addFileToGist,
+
+      /**
+       * Deletes a specified GitHub gist by its ID.
+       * @param gist_id - The ID of the gist to delete
+       * @param gist_name - The human-readable name of the gist (for logging purposes)
+       * @returns An Effect that succeeds when the gist is deleted
        */
-      addFileToGist
+      deleteGist
     }
   })
 }) {}
@@ -485,6 +618,14 @@ export class GistHandler extends Effect.Service<GistHandler>()("GistHandler", {
 
     return {
       handler: Effect.fn("effa-cli.gist.GistHandler")(function*({ YAMLPath }: { YAMLPath: string }) {
+        // load company and environment from environment variables
+        const CONFIG = yield* Effect.all({
+          company: Config.string("COMPANY"),
+          env: Config.string("ENV").pipe(Config.withDefault("local-dev"))
+        })
+
+        yield* Effect.logInfo(`Company: ${CONFIG.company}, ENV: ${CONFIG.env}`)
+
         yield* Effect.logInfo(`Reading configuration from ${YAMLPath}`)
 
         const configExists = yield* fs.exists(YAMLPath)
@@ -492,14 +633,14 @@ export class GistHandler extends Effect.Service<GistHandler>()("GistHandler", {
           return yield* Effect.fail(new Error(`Configuration file not found: ${YAMLPath}`))
         }
 
-        const config = yield* pipe(
+        const configFromYaml = yield* pipe(
           YAMLPath,
           fs.readFileString,
           Effect.andThen((content) =>
             Effect.try({
               try: () => yaml.load(content),
               catch(error) {
-                return new GistYAMLError({ reason: `Failed to parse YAML: ${(error as Error).message}` })
+                return new GistYAMLError({ message: `Failed to parse YAML: ${(error as Error).message}` })
               }
             })
           ),
@@ -507,17 +648,24 @@ export class GistHandler extends Effect.Service<GistHandler>()("GistHandler", {
         )
 
         // load GitHub token securely from environment variable
-        const redactedToken = yield* Config.redacted(config.settings.token_env)
+        const redactedToken = yield* Config.redacted(configFromYaml.settings.token_env)
 
-        yield* Effect.logInfo(`Using GitHub token from environment variable: ${config.settings.token_env}`)
+        yield* Effect.logInfo(`Using GitHub token from environment variable: ${configFromYaml.settings.token_env}`)
         yield* Effect.logInfo(`Token loaded: ${redactedToken}`) // this will show <redacted> in logs
 
         yield* GH.login(Redacted.value(redactedToken))
 
-        const cache = yield* SynchronizedRef.make<GistCache>(yield* GH.loadGistCache())
+        const cache = yield* SynchronizedRef.make<GistCache>(yield* GH.loadGistCache(CONFIG.company))
+
+        // filter YAML gists by company to ensure isolation between different organizations
+        // this prevents cross-company gist operations and maintains data separation
+        const thisCompanyGistsFromYaml = Object
+          .entries(configFromYaml.gists)
+          .filter(([, v]) => v.company === CONFIG.company)
 
-        // handle each gist entry in the configuration
-        for (const [name, gistConfig] of Object.entries(config.gists)) {
+        for (
+          const [name, gistConfig] of thisCompanyGistsFromYaml
+        ) {
           const { description, files_with_name, public: is_public } = gistConfig
 
           yield* Effect.logInfo(`Processing gist ${name}`)
@@ -526,7 +674,7 @@ export class GistHandler extends Effect.Service<GistHandler>()("GistHandler", {
             .all(
               files_with_name.map((f) =>
                 Effect.gen(function*() {
-                  const fullPath = path.join(config.settings.base_directory, f.path)
+                  const fullPath = path.join(configFromYaml.settings.base_directory, f.path)
                   const fileExists = yield* fs.exists(fullPath)
 
                   if (!fileExists) {
@@ -557,7 +705,8 @@ export class GistHandler extends Effect.Service<GistHandler>()("GistHandler", {
             const gistFileNames = new Set(
               yield* GH.getGistFileNames({
                 gist_id: gistFromCache.id,
-                gist_name: gistFromCache.name
+                gist_name: gistFromCache.name,
+                env: CONFIG.env
               })
             )
 
@@ -569,7 +718,8 @@ export class GistHandler extends Effect.Service<GistHandler>()("GistHandler", {
                 yield* GH.removeFileFromGist({
                   gist_id: gistFromCache.id,
                   gist_name: gistFromCache.name,
-                  file_name: gf
+                  file_name: gf,
+                  env: CONFIG.env
                 })
               }
             }
@@ -581,60 +731,84 @@ export class GistHandler extends Effect.Service<GistHandler>()("GistHandler", {
                   gist_id: gistFromCache.id,
                   gist_name: gistFromCache.name,
                   file_name: f.name,
-                  file_path: f.path
+                  file_path: f.path,
+                  env: CONFIG.env
                 })
               } else {
                 yield* GH.addFileToGist({
                   gist_id: gistFromCache.id,
                   gist_name: gistFromCache.name,
-                  file_path: f.path
+                  file: f,
+                  env: CONFIG.env
                 })
               }
             }
           } else {
             if (filesOnDiskWithFullPath.length !== 0) {
-              yield* SynchronizedRef.getAndUpdateEffect(cache, (cache) => {
-                return GH.createGistWithFiles({
-                  gist_name: name,
-                  description,
-                  is_public,
-                  cache,
-                  files: filesOnDiskWithFullPath.map((f) => f.path)
+              yield* SynchronizedRef.getAndUpdateEffect(
+                cache,
+                Effect.fnUntraced(function*(cache) {
+                  return new GistCache({
+                    gist_id: cache.gist_id,
+                    entries: [
+                      ...cache.entries,
+                      {
+                        ...(yield* GH.createGistWithFiles({
+                          gist_name: name,
+                          description,
+                          is_public,
+
+                          files: filesOnDiskWithFullPath,
+                          env: CONFIG.env
+                        }))
+                      }
+                    ],
+                    company: cache.company
+                  })
                 })
-              })
+              )
             } else {
               yield* Effect.logWarning(`No valid files found for gist ${name}, skipping creation...`)
             }
           }
+        }
 
-          // here the local cache has been updated, but not yet saved to GitHub
-          // we still want to remove gists from cache that are no longer in the configuration
-
-          const configGistNames = new Set(Object.entries(config.gists).map(([name]) => name))
-
-          const newCache = yield* SynchronizedRef.updateAndGetEffect(
-            cache,
-            Effect.fnUntraced(function*(cache) {
-              const newEntries = [...cache.entries]
+        // cache cleanup: remove gists that are no longer in YAML configuration
+        // only affects entries for the current company to maintain isolation
+        const configGistNames = new Set(
+          thisCompanyGistsFromYaml
+            .map(([name]) => name)
+        )
 
-              for (let i = newEntries.length - 1; i >= 0; i--) {
-                const cacheEntry = newEntries[i]
-                if (cacheEntry && !configGistNames.has(cacheEntry.name)) {
-                  yield* Effect.logInfo(
-                    `Obsolete gist ${cacheEntry.name} with ID ${cacheEntry.id}) will be removed from cache`
-                  )
-                  newEntries.splice(i, 1)
-                }
+        const newCache = yield* SynchronizedRef.updateAndGetEffect(
+          cache,
+          Effect.fnUntraced(function*(cache) {
+            const newEntries = [...cache.entries]
+
+            // remove obsolete cache entries for current company only
+            // this ensures gists from other companies remain untouched
+            for (let i = newEntries.length - 1; i >= 0; i--) {
+              const cacheEntry = newEntries[i]
+              if (cacheEntry && !configGistNames.has(cacheEntry.name)) {
+                // delete the actual gist from GitHub
+                yield* GH.deleteGist({
+                  gist_id: cacheEntry.id,
+                  gist_name: cacheEntry.name
+                })
+                yield* Effect.logInfo(
+                  `Obsolete gist ${cacheEntry.name} of company ${CONFIG.company} with ID ${cacheEntry.id}) will be removed from cache`
+                )
+                newEntries.splice(i, 1)
               }
+            }
 
-              return { ...cache, entries: newEntries }
-            })
-          )
+            return { ...cache, entries: newEntries }
+          })
+        )
 
-          yield* GH.saveGistCache(newCache)
+        yield* GH.saveGistCache(newCache)
 
-          yield* Effect.logInfo("Gist operations completed")
-        }
+        yield* Effect.logInfo("Gist operations completed")
       })
     }
   })