@macedon-technologies/batman 1.26.1 → 1.28.0

package/lib/SecretHandlerFiles.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretHandlerFiles = void 0;
+const projen_1 = require("projen");
+/**
+ * Scaffolds the Lambda handler sources used by the generated Secret construct
+ * (src/constructs/Secret.ts). Copied from @matthewbonig/secret (MIT).
+ *
+ * The entry file is deliberately not named *.lambda.ts, so projen's lambda
+ * auto-discovery does not generate a second function class for it.
+ */
+class SecretHandlerFiles {
+    constructor(project) {
+        new projen_1.SampleFile(project, 'src/constructs/handler/Secret.Function.ts', {
+            contents: `// Copied from @matthewbonig/secret (MIT, https://github.com/mbonig/secret).
+// This file is generated by Batman and is yours to modify.
+import { createSecretValue } from './secret/createSecretValue';
+import { updateSecretValue } from './secret/updateSecretValue';
+
+interface CustomResource {
+  RequestType: 'Create' | 'Update' | 'Delete';
+  LogicalResourceId: string;
+  ResourceProperties: any;
+  OldResourceProperties?: any;
+  PhysicalResourceId?: string;
+}
+
+export const handler = async (event: CustomResource) => {
+  console.log('Received event:', JSON.stringify(event, null, 2));
+
+  switch (event.RequestType) {
+    case 'Create':
+      console.log(\`Create secret value for secret \${event.LogicalResourceId};\`);
+      await createSecretValue({
+        secretArn: event.ResourceProperties.Secret,
+        generateSecretString: event.ResourceProperties.GenerateSecretString,
+      });
+      break;
+    case 'Update':
+      console.log('Updating secret with physical id:', event.PhysicalResourceId);
+      await updateSecretValue({
+        secretArn: event.ResourceProperties.Secret,
+        generateSecretString: event.ResourceProperties.GenerateSecretString,
+        oldGenerateSecretString: event.OldResourceProperties.GenerateSecretString,
+      });
+      break;
+    case 'Delete':
+      console.log('Deleting secret with physical id:', event.PhysicalResourceId);
+      console.log('Doing nothing. deleting secrets requires no work at all.');
+      break;
+  }
+};
+`,
+        });
+        new projen_1.SampleFile(project, 'src/constructs/handler/secret/client.ts', {
+            contents: `// Copied from @matthewbonig/secret (MIT, https://github.com/mbonig/secret).
+// This file is generated by Batman and is yours to modify.
+import { SecretsManager } from '@aws-sdk/client-secrets-manager';
+
+export const client = new SecretsManager({});
+`,
+        });
+        new projen_1.SampleFile(project, 'src/constructs/handler/secret/createSecretValue.ts', {
+            contents: `// Copied from @matthewbonig/secret (MIT, https://github.com/mbonig/secret).
+// This file is generated by Batman and is yours to modify.
+import { GetRandomPasswordCommand, PutSecretValueCommand } from '@aws-sdk/client-secrets-manager';
+import { client } from './client';
+
+export async function createSecretValue({ generateSecretString, secretArn }: {
+  secretArn: any;
+  generateSecretString: any;
+}) {
+  // since this is a create, we can just write the value as-is...
+  const secretValue = JSON.parse(generateSecretString.secretStringTemplate);
+  if (generateSecretString.generateStringKey) {
+    const randomValue = await client.send(new GetRandomPasswordCommand({
+      ExcludeCharacters: generateSecretString.excludeCharacters,
+      ExcludeLowercase: generateSecretString.excludeLowercase,
+      ExcludeNumbers: generateSecretString.excludeNumbers,
+      ExcludePunctuation: generateSecretString.excludePunctuation,
+      ExcludeUppercase: generateSecretString.excludeUppercase,
+      IncludeSpace: generateSecretString.includeSpace,
+      PasswordLength: generateSecretString.passwordLength,
+      RequireEachIncludedType: generateSecretString.requireEachIncludedType,
+    }));
+    secretValue[generateSecretString.generateStringKey] = randomValue.RandomPassword;
+  }
+
+  await client.send(new PutSecretValueCommand({
+    SecretId: secretArn,
+    SecretString: JSON.stringify(secretValue),
+  }));
+}
+`,
+        });
+        new projen_1.SampleFile(project, 'src/constructs/handler/secret/didRandomPropertiesChange.ts', {
+            contents: `// Copied from @matthewbonig/secret (MIT, https://github.com/mbonig/secret).
+// This file is generated by Batman and is yours to modify.
+export function didRandomPropertiesChange(oldGenerateSecretString: any, generateSecretString: any) {
+  return oldGenerateSecretString.excludeCharacters !== generateSecretString.excludeCharacters ||
+    oldGenerateSecretString.excludeLowercase !== generateSecretString.excludeLowercase ||
+    oldGenerateSecretString.excludeNumbers !== generateSecretString.excludeNumbers ||
+    oldGenerateSecretString.excludePunctuation !== generateSecretString.excludePunctuation ||
+    oldGenerateSecretString.excludeUppercase !== generateSecretString.excludeUppercase ||
+    oldGenerateSecretString.includeSpace !== generateSecretString.includeSpace ||
+    oldGenerateSecretString.passwordLength !== generateSecretString.passwordLength ||
+    oldGenerateSecretString.requireEachIncludedType !== generateSecretString.requireEachIncludedType;
+
+}
+`,
+        });
+        new projen_1.SampleFile(project, 'src/constructs/handler/secret/updateSecretValue.ts', {
+            contents: `// Copied from @matthewbonig/secret (MIT, https://github.com/mbonig/secret).
+// This file is generated by Batman and is yours to modify.
+import {
+  GetRandomPasswordCommand,
+  GetSecretValueCommand,
+  PutSecretValueCommand,
+} from '@aws-sdk/client-secrets-manager';
+import { client } from './client';
+import { didRandomPropertiesChange } from './didRandomPropertiesChange';
+
+export async function updateSecretValue({ oldGenerateSecretString, generateSecretString, secretArn }: {
+  secretArn: any;
+  generateSecretString: any;
+  oldGenerateSecretString: any;
+}) {
+  // let's get the existing value
+  const existingSecretValue = await client.send(new GetSecretValueCommand({
+    SecretId: secretArn,
+  }));
+  // and parse the existing value
+  let parsedValue: any = {};
+
+  try {
+    parsedValue = JSON.parse(existingSecretValue.SecretString!);
+  } catch (err) {
+    // the existing value couldn't be parsed, it was probably a random string.
+    // let's go ahead and just start fresh then,
+  }
+
+  // now let's check what properties have changed
+  const newSecretStringTemplate = JSON.parse(generateSecretString.secretStringTemplate);
+  const oldSecretStringTemplate = JSON.parse(oldGenerateSecretString.secretStringTemplate);
+  for (const key in newSecretStringTemplate) {
+    if (oldSecretStringTemplate[key] === undefined) {
+      // ok, so here's something to add...
+      parsedValue[key] = newSecretStringTemplate[key];
+    }
+    if (oldSecretStringTemplate[key] !== newSecretStringTemplate[key]) {
+      // ok, so here's something to update...
+      parsedValue[key] = newSecretStringTemplate[key];
+    }
+  }
+  for (const key in oldSecretStringTemplate) {
+    if (newSecretStringTemplate[key] === undefined) {
+      // ok, so here's something to remove...
+      delete parsedValue[key];
+    }
+  }
+
+  // did anything around the GenerateStringKey change?
+  if (didRandomPropertiesChange(oldGenerateSecretString, generateSecretString)
+    || generateSecretString.generateStringKey !== oldGenerateSecretString.generateStringKey) {
+    const { RandomPassword: newRandomValue } = await client.send(new GetRandomPasswordCommand({
+      ExcludeLowercase: generateSecretString.excludeLowercase === 'true',
+      ExcludeNumbers: generateSecretString.excludeNumbers === 'true',
+      ExcludePunctuation: generateSecretString.excludePunctuation === 'true',
+      ExcludeUppercase: generateSecretString.excludeUppercase === 'true',
+      IncludeSpace: generateSecretString.includeSpace === 'true',
+      PasswordLength: +generateSecretString.passwordLength,
+      RequireEachIncludedType: generateSecretString.requireEachIncludedType === 'true',
+    }));
+    parsedValue[generateSecretString.generateStringKey] = newRandomValue;
+  }
+
+  // update the secret in AWS
+  await client.send(new PutSecretValueCommand({
+    SecretId: secretArn,
+    SecretString: JSON.stringify(parsedValue),
+  }));
+
+}
+`,
+        });
+    }
+}
+exports.SecretHandlerFiles = SecretHandlerFiles;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SecretHandlerFiles.js","sourceRoot":"","sources":["../src/SecretHandlerFiles.ts"],"names":[],"mappings":";;;AAAA,mCAAoC;AAGpC;;;;;;GAMG;AACH,MAAa,kBAAkB;IAC7B,YAAY,OAA4B;QACtC,IAAI,mBAAU,CAAC,OAAO,EAAE,2CAA2C,EAAE;YACnE,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCf;SACI,CAAC,CAAC;QAEH,IAAI,mBAAU,CAAC,OAAO,EAAE,yCAAyC,EAAE;YACjE,QAAQ,EAAE;;;;;CAKf;SACI,CAAC,CAAC;QAEH,IAAI,mBAAU,CAAC,OAAO,EAAE,oDAAoD,EAAE;YAC5E,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Bf;SACI,CAAC,CAAC;QAEH,IAAI,mBAAU,CAAC,OAAO,EAAE,4DAA4D,EAAE;YACpF,QAAQ,EAAE;;;;;;;;;;;;;CAaf;SACI,CAAC,CAAC;QAEH,IAAI,mBAAU,CAAC,OAAO,EAAE,oDAAoD,EAAE;YAC5E,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEf;SACI,CAAC,CAAC;IACL,CAAC;CACF;AAnLD,gDAmLC","sourcesContent":["import { SampleFile } from 'projen';\nimport { AwsCdkTypeScriptApp } from 'projen/lib/awscdk';\n\n/**\n * Scaffolds the Lambda handler sources used by the generated Secret construct\n * (src/constructs/Secret.ts). Copied from @matthewbonig/secret (MIT).\n *\n * The entry file is deliberately not named *.lambda.ts, so projen's lambda\n * auto-discovery does not generate a second function class for it.\n */\nexport class SecretHandlerFiles {\n  constructor(project: AwsCdkTypeScriptApp) {\n    new SampleFile(project, 'src/constructs/handler/Secret.Function.ts', {\n      contents: `// Copied from @matthewbonig/secret (MIT, https://github.com/mbonig/secret).\n// This file is generated by Batman and is yours to modify.\nimport { createSecretValue } from './secret/createSecretValue';\nimport { updateSecretValue } from './secret/updateSecretValue';\n\ninterface CustomResource {\n  RequestType: 'Create' | 'Update' | 'Delete';\n  LogicalResourceId: string;\n  ResourceProperties: any;\n  OldResourceProperties?: any;\n  PhysicalResourceId?: string;\n}\n\nexport const handler = async (event: CustomResource) => {\n  console.log('Received event:', JSON.stringify(event, null, 2));\n\n  switch (event.RequestType) {\n    case 'Create':\n      console.log(\\`Create secret value for secret \\${event.LogicalResourceId};\\`);\n      await createSecretValue({\n        secretArn: event.ResourceProperties.Secret,\n        generateSecretString: event.ResourceProperties.GenerateSecretString,\n      });\n      break;\n    case 'Update':\n      console.log('Updating secret with physical id:', event.PhysicalResourceId);\n      await updateSecretValue({\n        secretArn: event.ResourceProperties.Secret,\n        generateSecretString: event.ResourceProperties.GenerateSecretString,\n        oldGenerateSecretString: event.OldResourceProperties.GenerateSecretString,\n      });\n      break;\n    case 'Delete':\n      console.log('Deleting secret with physical id:', event.PhysicalResourceId);\n      console.log('Doing nothing. deleting secrets requires no work at all.');\n      break;\n  }\n};\n`,\n    });\n\n    new SampleFile(project, 'src/constructs/handler/secret/client.ts', {\n      contents: `// Copied from @matthewbonig/secret (MIT, https://github.com/mbonig/secret).\n// This file is generated by Batman and is yours to modify.\nimport { SecretsManager } from '@aws-sdk/client-secrets-manager';\n\nexport const client = new SecretsManager({});\n`,\n    });\n\n    new SampleFile(project, 'src/constructs/handler/secret/createSecretValue.ts', {\n      contents: `// Copied from @matthewbonig/secret (MIT, https://github.com/mbonig/secret).\n// This file is generated by Batman and is yours to modify.\nimport { GetRandomPasswordCommand, PutSecretValueCommand } from '@aws-sdk/client-secrets-manager';\nimport { client } from './client';\n\nexport async function createSecretValue({ generateSecretString, secretArn }: {\n  secretArn: any;\n  generateSecretString: any;\n}) {\n  // since this is a create, we can just write the value as-is...\n  const secretValue = JSON.parse(generateSecretString.secretStringTemplate);\n  if (generateSecretString.generateStringKey) {\n    const randomValue = await client.send(new GetRandomPasswordCommand({\n      ExcludeCharacters: generateSecretString.excludeCharacters,\n      ExcludeLowercase: generateSecretString.excludeLowercase,\n      ExcludeNumbers: generateSecretString.excludeNumbers,\n      ExcludePunctuation: generateSecretString.excludePunctuation,\n      ExcludeUppercase: generateSecretString.excludeUppercase,\n      IncludeSpace: generateSecretString.includeSpace,\n      PasswordLength: generateSecretString.passwordLength,\n      RequireEachIncludedType: generateSecretString.requireEachIncludedType,\n    }));\n    secretValue[generateSecretString.generateStringKey] = randomValue.RandomPassword;\n  }\n\n  await client.send(new PutSecretValueCommand({\n    SecretId: secretArn,\n    SecretString: JSON.stringify(secretValue),\n  }));\n}\n`,\n    });\n\n    new SampleFile(project, 'src/constructs/handler/secret/didRandomPropertiesChange.ts', {\n      contents: `// Copied from @matthewbonig/secret (MIT, https://github.com/mbonig/secret).\n// This file is generated by Batman and is yours to modify.\nexport function didRandomPropertiesChange(oldGenerateSecretString: any, generateSecretString: any) {\n  return oldGenerateSecretString.excludeCharacters !== generateSecretString.excludeCharacters ||\n    oldGenerateSecretString.excludeLowercase !== generateSecretString.excludeLowercase ||\n    oldGenerateSecretString.excludeNumbers !== generateSecretString.excludeNumbers ||\n    oldGenerateSecretString.excludePunctuation !== generateSecretString.excludePunctuation ||\n    oldGenerateSecretString.excludeUppercase !== generateSecretString.excludeUppercase ||\n    oldGenerateSecretString.includeSpace !== generateSecretString.includeSpace ||\n    oldGenerateSecretString.passwordLength !== generateSecretString.passwordLength ||\n    oldGenerateSecretString.requireEachIncludedType !== generateSecretString.requireEachIncludedType;\n\n}\n`,\n    });\n\n    new SampleFile(project, 'src/constructs/handler/secret/updateSecretValue.ts', {\n      contents: `// Copied from @matthewbonig/secret (MIT, https://github.com/mbonig/secret).\n// This file is generated by Batman and is yours to modify.\nimport {\n  GetRandomPasswordCommand,\n  GetSecretValueCommand,\n  PutSecretValueCommand,\n} from '@aws-sdk/client-secrets-manager';\nimport { client } from './client';\nimport { didRandomPropertiesChange } from './didRandomPropertiesChange';\n\nexport async function updateSecretValue({ oldGenerateSecretString, generateSecretString, secretArn }: {\n  secretArn: any;\n  generateSecretString: any;\n  oldGenerateSecretString: any;\n}) {\n  // let's get the existing value\n  const existingSecretValue = await client.send(new GetSecretValueCommand({\n    SecretId: secretArn,\n  }));\n  // and parse the existing value\n  let parsedValue: any = {};\n\n  try {\n    parsedValue = JSON.parse(existingSecretValue.SecretString!);\n  } catch (err) {\n    // the existing value couldn't be parsed, it was probably a random string.\n    // let's go ahead and just start fresh then,\n  }\n\n  // now let's check what properties have changed\n  const newSecretStringTemplate = JSON.parse(generateSecretString.secretStringTemplate);\n  const oldSecretStringTemplate = JSON.parse(oldGenerateSecretString.secretStringTemplate);\n  for (const key in newSecretStringTemplate) {\n    if (oldSecretStringTemplate[key] === undefined) {\n      // ok, so here's something to add...\n      parsedValue[key] = newSecretStringTemplate[key];\n    }\n    if (oldSecretStringTemplate[key] !== newSecretStringTemplate[key]) {\n      // ok, so here's something to update...\n      parsedValue[key] = newSecretStringTemplate[key];\n    }\n  }\n  for (const key in oldSecretStringTemplate) {\n    if (newSecretStringTemplate[key] === undefined) {\n      // ok, so here's something to remove...\n      delete parsedValue[key];\n    }\n  }\n\n  // did anything around the GenerateStringKey change?\n  if (didRandomPropertiesChange(oldGenerateSecretString, generateSecretString)\n    || generateSecretString.generateStringKey !== oldGenerateSecretString.generateStringKey) {\n    const { RandomPassword: newRandomValue } = await client.send(new GetRandomPasswordCommand({\n      ExcludeLowercase: generateSecretString.excludeLowercase === 'true',\n      ExcludeNumbers: generateSecretString.excludeNumbers === 'true',\n      ExcludePunctuation: generateSecretString.excludePunctuation === 'true',\n      ExcludeUppercase: generateSecretString.excludeUppercase === 'true',\n      IncludeSpace: generateSecretString.includeSpace === 'true',\n      PasswordLength: +generateSecretString.passwordLength,\n      RequireEachIncludedType: generateSecretString.requireEachIncludedType === 'true',\n    }));\n    parsedValue[generateSecretString.generateStringKey] = newRandomValue;\n  }\n\n  // update the secret in AWS\n  await client.send(new PutSecretValueCommand({\n    SecretId: secretArn,\n    SecretString: JSON.stringify(parsedValue),\n  }));\n\n}\n`,\n    });\n  }\n}\n"]}

package/lib/SoftwareFactoryBootstrap.d.ts

@@ -0,0 +1,10 @@
+import { NodeProject } from 'projen/lib/javascript';
+/**
+ * The extension step of `swamp:bootstrap`: a Node script, so it runs the same
+ * under projen's PowerShell 5.1 task shell on Windows as under bash/sh, that
+ * pulls every extension at the version pinned in the repo's swamp lockfile.
+ * Fully generic — no per-repo parameterization.
+ */
+export declare class SoftwareFactoryBootstrap {
+    constructor(project: NodeProject);
+}

package/lib/SoftwareFactoryBootstrap.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftwareFactoryBootstrap = void 0;
+const projen_1 = require("projen");
+/**
+ * The extension step of `swamp:bootstrap`: a Node script, so it runs the same
+ * under projen's PowerShell 5.1 task shell on Windows as under bash/sh, that
+ * pulls every extension at the version pinned in the repo's swamp lockfile.
+ * Fully generic — no per-repo parameterization.
+ */
+class SoftwareFactoryBootstrap {
+    constructor(project) {
+        new projen_1.TextFile(project, 'swamp-bootstrap/pull-extensions.ts', {
+            marker: true,
+            lines: [
+                '/**',
+                ' * Pulls each swamp extension at the version pinned in',
+                ' * extensions/models/upstream_extensions.json, so a fresh clone runs the',
+                ' * same extensions as the rest of the team, including any the repo added',
+                ' * itself. A repo with no lockfile yet pulls DEFAULT_EXTENSIONS at their',
+                ' * latest stable versions, which creates the lockfile.',
+                ' *',
+                ' * A pull rewrites the lockfile even at an identical version, and on Windows',
+                ' * it writes backslash paths and deletes the committed files it tracks (e.g.',
+                ' * .claude/skills/software-factory/). So afterwards the lockfile and every',
+                ' * git-tracked file it lists are restored from git.',
+                ' */',
+                "import { execFileSync } from 'node:child_process';",
+                "import { existsSync, readFileSync } from 'node:fs';",
+                '',
+                "const LOCKFILE = 'extensions/models/upstream_extensions.json';",
+                "const DEFAULT_EXTENSIONS = ['@swamp/software-factory', '@webframp/github', '@goodcraft/github'];",
+                '',
+                'interface LockfileEntry {',
+                '  version: string;',
+                '  files?: string[];',
+                '}',
+                '',
+                'function readLockfile(): Record<string, LockfileEntry> | undefined {',
+                '  if (!existsSync(LOCKFILE)) {',
+                '    return undefined;',
+                '  }',
+                "  return JSON.parse(readFileSync(LOCKFILE, 'utf8')) as Record<string, LockfileEntry>;",
+                '}',
+                '',
+                'function run(command: string, args: string[]): string {',
+                "  return execFileSync(command, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'inherit'] });",
+                '}',
+                '',
+                'function pull(extension: string): void {',
+                '  console.log(`swamp extension pull ${extension} --force`);',
+                "  execFileSync('swamp', ['extension', 'pull', extension, '--force'], { stdio: 'inherit' });",
+                '}',
+                '',
+                'function restoreTrackedFiles(lockfile: Record<string, LockfileEntry>): void {',
+                '  const listed = Object.values(lockfile)',
+                '    .flatMap((entry) => entry.files ?? [])',
+                "    .map((file) => file.replace(/\\\\/g, '/'))",
+                "    .filter((file) => !file.startsWith('.swamp/'));",
+                "  const tracked = run('git', ['ls-files', '-z', '--', LOCKFILE, ...listed])",
+                "    .split('\\0')",
+                '    .filter(Boolean);',
+                '  if (tracked.length > 0) {',
+                "    run('git', ['checkout', '--', ...tracked]);",
+                '    console.log(`Restored ${tracked.length} tracked file(s) from git`);',
+                '  }',
+                '}',
+                '',
+                'function main(): void {',
+                '  const lockfile = readLockfile();',
+                '  if (!lockfile) {',
+                '    console.log(`No ${LOCKFILE} yet: pulling the latest stable software-factory extensions`);',
+                '    DEFAULT_EXTENSIONS.forEach(pull);',
+                '    return;',
+                '  }',
+                '',
+                '  for (const [name, entry] of Object.entries(lockfile)) {',
+                '    pull(`${name}@${entry.version}`);',
+                '  }',
+                '  restoreTrackedFiles(lockfile);',
+                '}',
+                '',
+                'main();',
+            ],
+        });
+        new projen_1.JsonFile(project, 'swamp-bootstrap/tsconfig.json', {
+            marker: false,
+            obj: {
+                extends: '../tsconfig.json',
+                compilerOptions: {
+                    noEmit: true,
+                    rootDir: '.',
+                },
+                include: ['*.ts'],
+                exclude: ['node_modules'],
+            },
+        });
+    }
+}
+exports.SoftwareFactoryBootstrap = SoftwareFactoryBootstrap;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/SoftwareFactoryFiles.d.ts

@@ -39,11 +39,13 @@ export interface SoftwareFactoryFilesOptions {
  * the repo is already initialized), so it's wired into the project's
  * `install`/`install:ci` tasks and runs automatically on every install,
  * guarded so it's a silent no-op on a machine without `swamp` on PATH (e.g.
- * CI). The extension pulls and vault creation are one-time, not idempotent
+ * CI). The extension pulls (at the versions pinned in the repo's
+ * `extensions/models/upstream_extensions.json`) and vault creation are one-time, not idempotent
  * in a way that's safe to repeat on every install, so they stay in the
  * `swamp:bootstrap` task this construct adds. Only exman's own authored
  * config (the factory's state machine, the architecture-rule engine, the
- * attestation mechanism, the OpenSpec task-completion gate, and the 3 swamp
+ * attestation mechanism, the OpenSpec task-completion gate, the lockfile-driven
+ * extension pull, and the 3 swamp
  * workflows that wire them together) is templated.
  */
 export declare class SoftwareFactoryFiles {

package/lib/SoftwareFactoryFiles.js

@@ -4,6 +4,7 @@ exports.SoftwareFactoryFiles = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const SoftwareFactoryArchitectureRules_1 = require("./SoftwareFactoryArchitectureRules");
 const SoftwareFactoryAttestation_1 = require("./SoftwareFactoryAttestation");
+const SoftwareFactoryBootstrap_1 = require("./SoftwareFactoryBootstrap");
 const SoftwareFactoryModels_1 = require("./SoftwareFactoryModels");
 const SoftwareFactoryOpenSpecGates_1 = require("./SoftwareFactoryOpenSpecGates");
 const SoftwareFactoryWorkflows_1 = require("./SoftwareFactoryWorkflows");
@@ -23,15 +24,17 @@ const DEFAULT_GITHUB_OWNER = 'macedon-technologies';
  * the repo is already initialized), so it's wired into the project's
  * `install`/`install:ci` tasks and runs automatically on every install,
  * guarded so it's a silent no-op on a machine without `swamp` on PATH (e.g.
- * CI). The extension pulls and vault creation are one-time, not idempotent
+ * CI). The extension pulls (at the versions pinned in the repo's
+ * `extensions/models/upstream_extensions.json`) and vault creation are one-time, not idempotent
  * in a way that's safe to repeat on every install, so they stay in the
  * `swamp:bootstrap` task this construct adds. Only exman's own authored
  * config (the factory's state machine, the architecture-rule engine, the
- * attestation mechanism, the OpenSpec task-completion gate, and the 3 swamp
+ * attestation mechanism, the OpenSpec task-completion gate, the lockfile-driven
+ * extension pull, and the 3 swamp
  * workflows that wire them together) is templated.
  */
 class SoftwareFactoryFiles {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.SoftwareFactoryFiles", version: "1.26.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.SoftwareFactoryFiles", version: "1.28.0" };
     constructor(project, options) {
         const { repoName, actionVersions } = options;
         const githubOwner = options.githubOwner || DEFAULT_GITHUB_OWNER;
@@ -51,6 +54,7 @@ class SoftwareFactoryFiles {
         new SoftwareFactoryAttestation_1.SoftwareFactoryAttestation(project, { repoName });
         new SoftwareFactoryOpenSpecGates_1.SoftwareFactoryOpenSpecGates(project);
         new SoftwareFactoryWorkflows_1.SoftwareFactoryWorkflows(project, { repoName, actionVersions });
+        new SoftwareFactoryBootstrap_1.SoftwareFactoryBootstrap(project);
         project.addTask('validate:architecture', {
             description: 'Run the architecture rule registry (architecture-rules/rules.json) against the repo',
             exec: 'ts-node --project architecture-rules/tsconfig.json architecture-rules/check.ts',
@@ -70,11 +74,9 @@ class SoftwareFactoryFiles {
             receiveArgs: true,
         });
         project.addTask('swamp:bootstrap', {
-            description: 'One-time setup: pull the software-factory/github extensions and create the secrets vault (swamp init itself already runs on every install)',
+            description: 'One-time setup: pull the swamp extensions at the versions pinned in extensions/models/upstream_extensions.json and create the secrets vault (swamp init itself already runs on every install)',
             steps: [
-                { exec: 'swamp extension pull @swamp/software-factory' },
-                { exec: 'swamp extension pull @webframp/github' },
-                { exec: 'swamp extension pull @goodcraft/github' },
+                { exec: 'ts-node --project swamp-bootstrap/tsconfig.json swamp-bootstrap/pull-extensions.ts' },
                 { exec: `swamp vault create local_encryption ${secretsVault}` },
                 {
                     exec: `echo "Next: swamp vault put ${secretsVault} GITHUB_TOKEN --refresh-from 'gh auth token'"`,
@@ -100,4 +102,4 @@ class SoftwareFactoryFiles {
     }
 }
 exports.SoftwareFactoryFiles = SoftwareFactoryFiles;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryFiles.js","sourceRoot":"","sources":["../src/SoftwareFactoryFiles.ts"],"names":[],"mappings":";;;;AACA,yFAAsF;AACtF,6EAA0E;AAC1E,mEAAgE;AAChE,iFAA8E;AAC9E,yEAAsE;AAGtE,MAAM,oBAAoB,GAAG,sBAAsB,CAAC;AA8BpD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,oBAAoB;;IAC/B,YAAY,OAAoB,EAAE,OAAoC;QACpE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;QAC7C,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,oBAAoB,CAAC;QAChE,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,MAAM,CAAC;QAChD,MAAM,YAAY,GAAG,GAAG,QAAQ,UAAU,CAAC;QAC3C,sEAAsE;QACtE,sEAAsE;QACtE,uEAAuE;QACvE,yEAAyE;QACzE,MAAM,aAAa,GAAG,iEAAiE,CAAC;QAExF,IAAI,6CAAqB,CAAC,OAAO,EAAE;YACjC,QAAQ;YACR,WAAW;YACX,UAAU;SACX,CAAC,CAAC;QAEH,IAAI,mEAAgC,CAAC,OAAO,CAAC,CAAC;QAE9C,IAAI,uDAA0B,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QAEtD,IAAI,2DAA4B,CAAC,OAAO,CAAC,CAAC;QAE1C,IAAI,mDAAwB,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,CAAC;QAEpE,OAAO,CAAC,OAAO,CAAC,uBAAuB,EAAE;YACvC,WAAW,EAAE,qFAAqF;YAClG,IAAI,EAAE,gFAAgF;SACvF,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,+BAA+B,EAAE;YAC/C,WAAW,EAAE,2FAA2F;YACxG,IAAI,EAAE,uFAAuF;YAC7F,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,sBAAsB,EAAE;YACtC,WAAW,EAAE,wGAAwG;YACrH,IAAI,EAAE,qEAAqE;SAC5E,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,oBAAoB,EAAE;YACpC,WAAW,EAAE,yHAAyH;YACtI,IAAI,EAAE,mEAAmE;YACzE,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,iBAAiB,EAAE;YACjC,WAAW,EAAE,4IAA4I;YACzJ,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,8CAA8C,EAAE;gBACxD,EAAE,IAAI,EAAE,uCAAuC,EAAE;gBACjD,EAAE,IAAI,EAAE,wCAAwC,EAAE;gBAClD,EAAE,IAAI,EAAE,uCAAuC,YAAY,EAAE,EAAE;gBAC/D;oBACE,IAAI,EAAE,+BAA+B,YAAY,+CAA+C;iBACjG;aACF;SACF,CAAC,CAAC;QAEH,wEAAwE;QACxE,wEAAwE;QACxE,yEAAyE;QACzE,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAChD,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAElD,uEAAuE;QACvE,wEAAwE;QACxE,uEAAuE;QACvE,mEAAmE;QACnE,oDAAoD;QACpD,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAChC,OAAO,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;QAC5C,OAAO,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;QAC3C,OAAO,CAAC,YAAY,CAAC,6BAA6B,CAAC,CAAC;QACpD,OAAO,CAAC,YAAY,CAAC,8BAA8B,CAAC,CAAC;QACrD,OAAO,CAAC,YAAY,CAAC,8BAA8B,CAAC,CAAC;IACvD,CAAC;;AA9EH,oDA+EC","sourcesContent":["import { NodeProject } from 'projen/lib/javascript';\nimport { SoftwareFactoryArchitectureRules } from './SoftwareFactoryArchitectureRules';\nimport { SoftwareFactoryAttestation } from './SoftwareFactoryAttestation';\nimport { SoftwareFactoryModels } from './SoftwareFactoryModels';\nimport { SoftwareFactoryOpenSpecGates } from './SoftwareFactoryOpenSpecGates';\nimport { SoftwareFactoryWorkflows } from './SoftwareFactoryWorkflows';\nimport { WorkflowActionVersions } from './WorkflowActionVersions';\n\nconst DEFAULT_GITHUB_OWNER = 'macedon-technologies';\n\nexport interface SoftwareFactoryFilesOptions {\n  /**\n   * The bare repo name (e.g. `expense-tracker`), used to derive the factory's\n   * model names (`<repoName>-factory`, `<repoName>-issues`, `<repoName>-pr`,\n   * `<repoName>-shell*`) and vault name (`<repoName>-secrets`).\n   */\n  readonly repoName: string;\n\n  /**\n   * The GitHub org/user the repo lives in.\n   *\n   * @default 'macedon-technologies'\n   */\n  readonly githubOwner?: string;\n\n  /**\n   * The branch the factory opens pull requests against.\n   *\n   * @default 'main'\n   */\n  readonly baseBranch?: string;\n\n  /**\n   * Overrides for the pinned action versions used by `verify-attestation.yml`.\n   */\n  readonly actionVersions?: WorkflowActionVersions;\n}\n\n/**\n * Backports exman's swamp \"software factory\" pattern\n * (macedon-technologies/exman#13) as generated scaffolding: a\n * `@swamp/software-factory` state machine that drives a GitHub issue from\n * intake through an opened PR, enforcing OpenSpec usage, an architecture\n * rule registry, and a pre-PR verification gate whose attestation is\n * re-checked at merge time.\n *\n * What swamp itself would generate (extension docs pulled via\n * `swamp extension pull`, `.swamp.yaml`, the vault, and the \"swamp managed\n * section\" in CLAUDE.md) is deliberately NOT hand-templated here — those are\n * produced by the real `swamp` CLI. `swamp init` is idempotent (a no-op if\n * the repo is already initialized), so it's wired into the project's\n * `install`/`install:ci` tasks and runs automatically on every install,\n * guarded so it's a silent no-op on a machine without `swamp` on PATH (e.g.\n * CI). The extension pulls and vault creation are one-time, not idempotent\n * in a way that's safe to repeat on every install, so they stay in the\n * `swamp:bootstrap` task this construct adds. Only exman's own authored\n * config (the factory's state machine, the architecture-rule engine, the\n * attestation mechanism, the OpenSpec task-completion gate, and the 3 swamp\n * workflows that wire them together) is templated.\n */\nexport class SoftwareFactoryFiles {\n  constructor(project: NodeProject, options: SoftwareFactoryFilesOptions) {\n    const { repoName, actionVersions } = options;\n    const githubOwner = options.githubOwner || DEFAULT_GITHUB_OWNER;\n    const baseBranch = options.baseBranch || 'main';\n    const secretsVault = `${repoName}-secrets`;\n    // A single redirect only: projen's built-in cross-platform task shell\n    // (dax) rejects a command with more than one redirect (e.g. combining\n    // `>/dev/null` with `2>&1`) with \"Multiple redirects are currently not\n    // supported\" — confirmed by dogfooding this construct on this very repo.\n    const swampInitStep = 'command -v swamp >/dev/null && swamp init --tool claude || true';\n\n    new SoftwareFactoryModels(project, {\n      repoName,\n      githubOwner,\n      baseBranch,\n    });\n\n    new SoftwareFactoryArchitectureRules(project);\n\n    new SoftwareFactoryAttestation(project, { repoName });\n\n    new SoftwareFactoryOpenSpecGates(project);\n\n    new SoftwareFactoryWorkflows(project, { repoName, actionVersions });\n\n    project.addTask('validate:architecture', {\n      description: 'Run the architecture rule registry (architecture-rules/rules.json) against the repo',\n      exec: 'ts-node --project architecture-rules/tsconfig.json architecture-rules/check.ts',\n    });\n\n    project.addTask('openspec:check-tasks-complete', {\n      description: 'Fail unless every task in the named OpenSpec change is complete (usage: -- <change-slug>)',\n      exec: 'ts-node --project openspec-gates/tsconfig.json openspec-gates/check-tasks-complete.ts',\n      receiveArgs: true,\n    });\n\n    project.addTask('attestation:manifest', {\n      description: 'Print SHA256 checksums of the files a PR attestation is verified against (see attestation/manifest.ts)',\n      exec: 'ts-node --project attestation/tsconfig.json attestation/manifest.ts',\n    });\n\n    project.addTask('attestation:verify', {\n      description: 'Verify a PR\\'s embedded attestation-manifest against the current checkout (usage: -- --body-file <path> --commit <sha>)',\n      exec: 'ts-node --project attestation/tsconfig.json attestation/verify.ts',\n      receiveArgs: true,\n    });\n\n    project.addTask('swamp:bootstrap', {\n      description: 'One-time setup: pull the software-factory/github extensions and create the secrets vault (swamp init itself already runs on every install)',\n      steps: [\n        { exec: 'swamp extension pull @swamp/software-factory' },\n        { exec: 'swamp extension pull @webframp/github' },\n        { exec: 'swamp extension pull @goodcraft/github' },\n        { exec: `swamp vault create local_encryption ${secretsVault}` },\n        {\n          exec: `echo \"Next: swamp vault put ${secretsVault} GITHUB_TOKEN --refresh-from 'gh auth token'\"`,\n        },\n      ],\n    });\n\n    // `swamp init` is safe to re-run (idempotent when already initialized),\n    // so every install keeps the repo initialized without a separate manual\n    // step — including on a fresh clone that hasn't run swamp:bootstrap yet.\n    project.package.installTask.exec(swampInitStep);\n    project.package.installCiTask.exec(swampInitStep);\n\n    // Mirrors the patterns `swamp init` itself would append to .gitignore.\n    // projen's IgnoreFile fully regenerates .gitignore from its own tracked\n    // entries on every synth, so anything `swamp init` appends out-of-band\n    // gets silently wiped by the next `npx projen` run (caught by CI's\n    // self-mutation check) unless it's also added here.\n    project.addGitIgnore('.swamp/');\n    project.addGitIgnore('.swamp-sources.yaml');\n    project.addGitIgnore('.claude/worktrees/');\n    project.addGitIgnore('.claude/settings.local.json');\n    project.addGitIgnore('.claude/scheduled_tasks.lock');\n    project.addGitIgnore('.claude/scheduled_tasks.json');\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryFiles.js","sourceRoot":"","sources":["../src/SoftwareFactoryFiles.ts"],"names":[],"mappings":";;;;AACA,yFAAsF;AACtF,6EAA0E;AAC1E,yEAAsE;AACtE,mEAAgE;AAChE,iFAA8E;AAC9E,yEAAsE;AAGtE,MAAM,oBAAoB,GAAG,sBAAsB,CAAC;AA8BpD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAa,oBAAoB;;IAC/B,YAAY,OAAoB,EAAE,OAAoC;QACpE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;QAC7C,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,oBAAoB,CAAC;QAChE,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,MAAM,CAAC;QAChD,MAAM,YAAY,GAAG,GAAG,QAAQ,UAAU,CAAC;QAC3C,sEAAsE;QACtE,sEAAsE;QACtE,uEAAuE;QACvE,yEAAyE;QACzE,MAAM,aAAa,GAAG,iEAAiE,CAAC;QAExF,IAAI,6CAAqB,CAAC,OAAO,EAAE;YACjC,QAAQ;YACR,WAAW;YACX,UAAU;SACX,CAAC,CAAC;QAEH,IAAI,mEAAgC,CAAC,OAAO,CAAC,CAAC;QAE9C,IAAI,uDAA0B,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QAEtD,IAAI,2DAA4B,CAAC,OAAO,CAAC,CAAC;QAE1C,IAAI,mDAAwB,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,CAAC;QAEpE,IAAI,mDAAwB,CAAC,OAAO,CAAC,CAAC;QAEtC,OAAO,CAAC,OAAO,CAAC,uBAAuB,EAAE;YACvC,WAAW,EAAE,qFAAqF;YAClG,IAAI,EAAE,gFAAgF;SACvF,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,+BAA+B,EAAE;YAC/C,WAAW,EAAE,2FAA2F;YACxG,IAAI,EAAE,uFAAuF;YAC7F,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,sBAAsB,EAAE;YACtC,WAAW,EAAE,wGAAwG;YACrH,IAAI,EAAE,qEAAqE;SAC5E,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,oBAAoB,EAAE;YACpC,WAAW,EAAE,yHAAyH;YACtI,IAAI,EAAE,mEAAmE;YACzE,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,iBAAiB,EAAE;YACjC,WAAW,EAAE,+LAA+L;YAC5M,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,oFAAoF,EAAE;gBAC9F,EAAE,IAAI,EAAE,uCAAuC,YAAY,EAAE,EAAE;gBAC/D;oBACE,IAAI,EAAE,+BAA+B,YAAY,+CAA+C;iBACjG;aACF;SACF,CAAC,CAAC;QAEH,wEAAwE;QACxE,wEAAwE;QACxE,yEAAyE;QACzE,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAChD,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAElD,uEAAuE;QACvE,wEAAwE;QACxE,uEAAuE;QACvE,mEAAmE;QACnE,oDAAoD;QACpD,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAChC,OAAO,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;QAC5C,OAAO,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;QAC3C,OAAO,CAAC,YAAY,CAAC,6BAA6B,CAAC,CAAC;QACpD,OAAO,CAAC,YAAY,CAAC,8BAA8B,CAAC,CAAC;QACrD,OAAO,CAAC,YAAY,CAAC,8BAA8B,CAAC,CAAC;IACvD,CAAC;;AA9EH,oDA+EC","sourcesContent":["import { NodeProject } from 'projen/lib/javascript';\nimport { SoftwareFactoryArchitectureRules } from './SoftwareFactoryArchitectureRules';\nimport { SoftwareFactoryAttestation } from './SoftwareFactoryAttestation';\nimport { SoftwareFactoryBootstrap } from './SoftwareFactoryBootstrap';\nimport { SoftwareFactoryModels } from './SoftwareFactoryModels';\nimport { SoftwareFactoryOpenSpecGates } from './SoftwareFactoryOpenSpecGates';\nimport { SoftwareFactoryWorkflows } from './SoftwareFactoryWorkflows';\nimport { WorkflowActionVersions } from './WorkflowActionVersions';\n\nconst DEFAULT_GITHUB_OWNER = 'macedon-technologies';\n\nexport interface SoftwareFactoryFilesOptions {\n  /**\n   * The bare repo name (e.g. `expense-tracker`), used to derive the factory's\n   * model names (`<repoName>-factory`, `<repoName>-issues`, `<repoName>-pr`,\n   * `<repoName>-shell*`) and vault name (`<repoName>-secrets`).\n   */\n  readonly repoName: string;\n\n  /**\n   * The GitHub org/user the repo lives in.\n   *\n   * @default 'macedon-technologies'\n   */\n  readonly githubOwner?: string;\n\n  /**\n   * The branch the factory opens pull requests against.\n   *\n   * @default 'main'\n   */\n  readonly baseBranch?: string;\n\n  /**\n   * Overrides for the pinned action versions used by `verify-attestation.yml`.\n   */\n  readonly actionVersions?: WorkflowActionVersions;\n}\n\n/**\n * Backports exman's swamp \"software factory\" pattern\n * (macedon-technologies/exman#13) as generated scaffolding: a\n * `@swamp/software-factory` state machine that drives a GitHub issue from\n * intake through an opened PR, enforcing OpenSpec usage, an architecture\n * rule registry, and a pre-PR verification gate whose attestation is\n * re-checked at merge time.\n *\n * What swamp itself would generate (extension docs pulled via\n * `swamp extension pull`, `.swamp.yaml`, the vault, and the \"swamp managed\n * section\" in CLAUDE.md) is deliberately NOT hand-templated here — those are\n * produced by the real `swamp` CLI. `swamp init` is idempotent (a no-op if\n * the repo is already initialized), so it's wired into the project's\n * `install`/`install:ci` tasks and runs automatically on every install,\n * guarded so it's a silent no-op on a machine without `swamp` on PATH (e.g.\n * CI). The extension pulls (at the versions pinned in the repo's\n * `extensions/models/upstream_extensions.json`) and vault creation are one-time, not idempotent\n * in a way that's safe to repeat on every install, so they stay in the\n * `swamp:bootstrap` task this construct adds. Only exman's own authored\n * config (the factory's state machine, the architecture-rule engine, the\n * attestation mechanism, the OpenSpec task-completion gate, the lockfile-driven\n * extension pull, and the 3 swamp\n * workflows that wire them together) is templated.\n */\nexport class SoftwareFactoryFiles {\n  constructor(project: NodeProject, options: SoftwareFactoryFilesOptions) {\n    const { repoName, actionVersions } = options;\n    const githubOwner = options.githubOwner || DEFAULT_GITHUB_OWNER;\n    const baseBranch = options.baseBranch || 'main';\n    const secretsVault = `${repoName}-secrets`;\n    // A single redirect only: projen's built-in cross-platform task shell\n    // (dax) rejects a command with more than one redirect (e.g. combining\n    // `>/dev/null` with `2>&1`) with \"Multiple redirects are currently not\n    // supported\" — confirmed by dogfooding this construct on this very repo.\n    const swampInitStep = 'command -v swamp >/dev/null && swamp init --tool claude || true';\n\n    new SoftwareFactoryModels(project, {\n      repoName,\n      githubOwner,\n      baseBranch,\n    });\n\n    new SoftwareFactoryArchitectureRules(project);\n\n    new SoftwareFactoryAttestation(project, { repoName });\n\n    new SoftwareFactoryOpenSpecGates(project);\n\n    new SoftwareFactoryWorkflows(project, { repoName, actionVersions });\n\n    new SoftwareFactoryBootstrap(project);\n\n    project.addTask('validate:architecture', {\n      description: 'Run the architecture rule registry (architecture-rules/rules.json) against the repo',\n      exec: 'ts-node --project architecture-rules/tsconfig.json architecture-rules/check.ts',\n    });\n\n    project.addTask('openspec:check-tasks-complete', {\n      description: 'Fail unless every task in the named OpenSpec change is complete (usage: -- <change-slug>)',\n      exec: 'ts-node --project openspec-gates/tsconfig.json openspec-gates/check-tasks-complete.ts',\n      receiveArgs: true,\n    });\n\n    project.addTask('attestation:manifest', {\n      description: 'Print SHA256 checksums of the files a PR attestation is verified against (see attestation/manifest.ts)',\n      exec: 'ts-node --project attestation/tsconfig.json attestation/manifest.ts',\n    });\n\n    project.addTask('attestation:verify', {\n      description: 'Verify a PR\\'s embedded attestation-manifest against the current checkout (usage: -- --body-file <path> --commit <sha>)',\n      exec: 'ts-node --project attestation/tsconfig.json attestation/verify.ts',\n      receiveArgs: true,\n    });\n\n    project.addTask('swamp:bootstrap', {\n      description: 'One-time setup: pull the swamp extensions at the versions pinned in extensions/models/upstream_extensions.json and create the secrets vault (swamp init itself already runs on every install)',\n      steps: [\n        { exec: 'ts-node --project swamp-bootstrap/tsconfig.json swamp-bootstrap/pull-extensions.ts' },\n        { exec: `swamp vault create local_encryption ${secretsVault}` },\n        {\n          exec: `echo \"Next: swamp vault put ${secretsVault} GITHUB_TOKEN --refresh-from 'gh auth token'\"`,\n        },\n      ],\n    });\n\n    // `swamp init` is safe to re-run (idempotent when already initialized),\n    // so every install keeps the repo initialized without a separate manual\n    // step — including on a fresh clone that hasn't run swamp:bootstrap yet.\n    project.package.installTask.exec(swampInitStep);\n    project.package.installCiTask.exec(swampInitStep);\n\n    // Mirrors the patterns `swamp init` itself would append to .gitignore.\n    // projen's IgnoreFile fully regenerates .gitignore from its own tracked\n    // entries on every synth, so anything `swamp init` appends out-of-band\n    // gets silently wiped by the next `npx projen` run (caught by CI's\n    // self-mutation check) unless it's also added here.\n    project.addGitIgnore('.swamp/');\n    project.addGitIgnore('.swamp-sources.yaml');\n    project.addGitIgnore('.claude/worktrees/');\n    project.addGitIgnore('.claude/settings.local.json');\n    project.addGitIgnore('.claude/scheduled_tasks.lock');\n    project.addGitIgnore('.claude/scheduled_tasks.json');\n  }\n}\n"]}

package/lib/StagingDeployWorkflow.js

@@ -7,7 +7,7 @@ const javascript_1 = require("projen/lib/javascript");
 const utils_1 = require("./utils");
 const WorkflowActionVersions_1 = require("./WorkflowActionVersions");
 class StagingDeployWorkflow extends projen_1.YamlFile {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.StagingDeployWorkflow", version: "1.26.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.StagingDeployWorkflow", version: "1.28.0" };
     constructor(project, options) {
         const packageManager = project.package.packageManager;
         const actionVersions = (0, WorkflowActionVersions_1.resolveActionVersions)(options.actionVersions);