npm - github-issue-tower-defence-management - Versions diffs - 1.109.2 → 1.110.1 - Mend

github-issue-tower-defence-management 1.109.2 → 1.110.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (201) hide show

package/src/adapter/entry-points/console/ui-dist/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-BpccigBS.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CO-f_j4f.css">
+    <script type="module" crossorigin src="/assets/index-CT3t4Yje.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BPH6W1yn.css">
   </head>
   <body>
     <div id="root"></div>

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts CHANGED Viewed

@@ -9,6 +9,10 @@ import { writeTokenStatus } from './tokenStatusWriter';
 import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
 import { reconcileInTmuxByHumanSessions } from './inTmuxByHumanSessionReconciler';
 import { cleanStaleTmuxSessions } from './staleTmuxSessionCleaner';
+import {
+  notifySilentTmuxSessions,
+  DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS,
+} from './notifySilentTmuxSessions';
 import { writeRotationOrderFile } from './rotationOrderFileWriter';
 import {
   fetchProjectReadme,
@@ -61,6 +65,23 @@ import {
 const DEFAULT_DASHBOARD_DATA_DIR: string | null = null;
+const readSilentSeconds = (
+  configValue: number | undefined,
+  envValue: string | undefined,
+  defaultValue: number,
+): number => {
+  if (configValue !== undefined) {
+    return configValue;
+  }
+  if (envValue !== undefined) {
+    const parsed = Number(envValue);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return defaultValue;
+};
 export class HandleScheduledEventUseCaseHandler {
   handle = async (
     configFilePath: string,
@@ -87,6 +108,20 @@ export class HandleScheduledEventUseCaseHandler {
       inTmuxConsoleToken?: string;
       inTmuxProjectOrder?: string[];
       inTmuxLauncherCommand?: string;
+      sessionOutputRootDirectory?: string;
+      sessionTranscriptRootDirectory?: string;
+      ownerCallMarker?: string;
+      subAgentOutputRootDirectory?: string;
+      subAgentProcessMatchPattern?: string;
+      subAgentTranscriptRootDirectory?: string;
+      mainSilentThresholdSeconds?: number;
+      subAgentSilentThresholdSeconds?: number;
+      subAgentRunningThresholdSeconds?: number;
+      silentNotificationCooldownSeconds?: number;
+      silentNotificationStaggerSeconds?: number;
+      silentMainStalledMessage?: string;
+      silentSubAgentMessageHeader?: string;
+      silentSubAgentMessageFooter?: string;
       credentials: {
         manager: {
           github: {
@@ -461,6 +496,7 @@ export class HandleScheduledEventUseCaseHandler {
           tokenListJsonPath:
             mergedInput.claudeCodeOauthTokenListJsonPath ?? null,
           issues: result.issues,
+          pjcode: input.projectName,
         });
       } catch (error) {
         console.error(
@@ -525,6 +561,92 @@ export class HandleScheduledEventUseCaseHandler {
           }`,
         );
       }
+      try {
+        const sessionOutputRootDirectory =
+          mergedInput.sessionOutputRootDirectory ??
+          process.env.TDPM_SESSION_OUTPUT_ROOT_DIRECTORY ??
+          null;
+        const subAgentOutputRootDirectory =
+          mergedInput.subAgentOutputRootDirectory ??
+          process.env.TDPM_SUBAGENT_OUTPUT_ROOT_DIRECTORY ??
+          null;
+        const subAgentProcessMatchPattern =
+          mergedInput.subAgentProcessMatchPattern ??
+          process.env.TDPM_SUBAGENT_PROCESS_MATCH_PATTERN ??
+          null;
+        const sessionTranscriptRootDirectory =
+          mergedInput.sessionTranscriptRootDirectory ??
+          process.env.TDPM_SESSION_TRANSCRIPT_ROOT_DIRECTORY ??
+          null;
+        const ownerCallMarker =
+          mergedInput.ownerCallMarker ??
+          process.env.TDPM_SILENT_OWNER_CALL_MARKER ??
+          null;
+        const subAgentTranscriptRootDirectory =
+          mergedInput.subAgentTranscriptRootDirectory ??
+          process.env.TDPM_SUBAGENT_TRANSCRIPT_ROOT_DIRECTORY ??
+          null;
+        await notifySilentTmuxSessions({
+          project: result.project,
+          allowCacheMinutes: mergedInput.allowIssueCacheMinutes,
+          issueRepository,
+          localCommandRunner: nodeLocalCommandRunner,
+          cacheRepository: localStorageCacheRepository,
+          sessionOutputRootDirectory,
+          sessionTranscriptRootDirectory,
+          ownerCallMarker,
+          subAgentOutputRootDirectory,
+          subAgentProcessMatchPattern,
+          subAgentTranscriptRootDirectory,
+          mainSilentThresholdSeconds: readSilentSeconds(
+            mergedInput.mainSilentThresholdSeconds,
+            process.env.TDPM_MAIN_SILENT_THRESHOLD_SECONDS,
+            DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS.mainSilentThresholdSeconds,
+          ),
+          subAgentSilentThresholdSeconds: readSilentSeconds(
+            mergedInput.subAgentSilentThresholdSeconds,
+            process.env.TDPM_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+            DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS.subAgentSilentThresholdSeconds,
+          ),
+          subAgentRunningThresholdSeconds: readSilentSeconds(
+            mergedInput.subAgentRunningThresholdSeconds,
+            process.env.TDPM_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
+            DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS.subAgentRunningThresholdSeconds,
+          ),
+          cooldownSeconds: readSilentSeconds(
+            mergedInput.silentNotificationCooldownSeconds,
+            process.env.TDPM_SILENT_NOTIFICATION_COOLDOWN_SECONDS,
+            DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS.cooldownSeconds,
+          ),
+          staggerSeconds: readSilentSeconds(
+            mergedInput.silentNotificationStaggerSeconds,
+            process.env.TDPM_SILENT_NOTIFICATION_STAGGER_SECONDS,
+            DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS.staggerSeconds,
+          ),
+          messageTemplates: {
+            mainStalledMessage:
+              mergedInput.silentMainStalledMessage ??
+              process.env.TDPM_SILENT_MAIN_STALLED_MESSAGE ??
+              null,
+            subAgentMessageHeader:
+              mergedInput.silentSubAgentMessageHeader ??
+              process.env.TDPM_SILENT_SUBAGENT_MESSAGE_HEADER ??
+              null,
+            subAgentMessageFooter:
+              mergedInput.silentSubAgentMessageFooter ??
+              process.env.TDPM_SILENT_SUBAGENT_MESSAGE_FOOTER ??
+              null,
+          },
+          now: inTmuxNow,
+        });
+      } catch (error) {
+        console.error(
+          `Failed to notify silent tmux sessions: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
     }
     return result;
   };

package/src/adapter/entry-points/handlers/InTmuxByHumanSessionTokenCountHandler.ts CHANGED Viewed

@@ -50,6 +50,8 @@ export class InTmuxByHumanSessionTokenCountHandler {
         name,
         token,
         snapshot: null,
+        subscriptionDisabled: false,
+        unifiedRejected: false,
       }),
     );

package/src/adapter/entry-points/handlers/LiveSessionOauthTokenSelectHandler.test.ts CHANGED Viewed

@@ -85,6 +85,28 @@ describe('LiveSessionOauthTokenSelectHandler', () => {
     );
   };
+  const writeSubscriptionDisabledCache = (
+    token: string,
+    epochSeconds: number = Date.now() / 1000,
+  ): void => {
+    const payload = { subscriptionDisabledEpoch: epochSeconds };
+    fs.writeFileSync(
+      path.join(cacheDirectory, `${hashToken(token)}.json`),
+      JSON.stringify(payload),
+    );
+  };
+  const writeCacheWithHeaders = (
+    token: string,
+    headers: Record<string, string>,
+  ): void => {
+    const payload = { ts: NOW, headers, modelWeeklyLimits: {} };
+    fs.writeFileSync(
+      path.join(cacheDirectory, `${hashToken(token)}.json`),
+      JSON.stringify(payload),
+    );
+  };
   const buildHandler = (
     sessions: ClaudeLiveSession[],
   ): LiveSessionOauthTokenSelectHandler =>
@@ -289,4 +311,94 @@ describe('LiveSessionOauthTokenSelectHandler', () => {
     expect(output.selectedToken).toBeNull();
     expect(output.diagnostics.join('\n')).toContain('No usable token entries');
   });
+  it('excludes a subscription-disabled token even when it has zero live sessions', () => {
+    writeTokenList([
+      { name: 'disabled', token: 'fake-disabled' },
+      { name: 'active', token: 'fake-active' },
+    ]);
+    writeSubscriptionDisabledCache('fake-disabled');
+    writeCache('fake-active', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+    const handler = buildHandler([
+      { token: 'fake-active', sessionId: 'session-a' },
+    ]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('active');
+    expect(output.diagnostics.join('\n')).toContain(
+      'organization has disabled Claude subscription access for Claude Code',
+    );
+  });
+  it('excludes a unified-rejected token even when it has zero live sessions', () => {
+    writeTokenList([
+      { name: 'rejected', token: 'fake-rejected' },
+      { name: 'active', token: 'fake-active' },
+    ]);
+    writeCacheWithHeaders('fake-rejected', {
+      'anthropic-ratelimit-unified-status': 'rejected',
+      'anthropic-ratelimit-unified-5h-status': 'allowed',
+      'anthropic-ratelimit-unified-5h-reset': String(NOW + HOUR),
+      'anthropic-ratelimit-unified-5h-utilization': '0.1',
+      'anthropic-ratelimit-unified-7d-status': 'allowed',
+      'anthropic-ratelimit-unified-7d-reset': String(NOW + DAY),
+      'anthropic-ratelimit-unified-7d-utilization': '0.1',
+    });
+    writeCache('fake-active', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+    const handler = buildHandler([
+      { token: 'fake-active', sessionId: 'session-a' },
+    ]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('active');
+    expect(output.diagnostics.join('\n')).toContain('rejected');
+  });
+  it('returns null and a no-eligible-token diagnostic when every token is unusable', () => {
+    writeTokenList([
+      { name: 'disabled', token: 'fake-disabled' },
+      { name: 'rejected', token: 'fake-rejected' },
+    ]);
+    writeSubscriptionDisabledCache('fake-disabled');
+    writeCacheWithHeaders('fake-rejected', {
+      'anthropic-ratelimit-unified-status': 'rejected',
+      'anthropic-ratelimit-unified-5h-status': 'allowed',
+      'anthropic-ratelimit-unified-5h-reset': String(NOW + HOUR),
+      'anthropic-ratelimit-unified-5h-utilization': '0.1',
+      'anthropic-ratelimit-unified-7d-status': 'allowed',
+      'anthropic-ratelimit-unified-7d-reset': String(NOW + DAY),
+      'anthropic-ratelimit-unified-7d-utilization': '0.1',
+    });
+    const handler = buildHandler([]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedToken).toBeNull();
+    expect(output.selectedName).toBeNull();
+    expect(output.diagnostics.join('\n')).toContain('No eligible token');
+  });
 });

package/src/adapter/entry-points/handlers/LiveSessionOauthTokenSelectHandler.ts CHANGED Viewed

@@ -75,6 +75,8 @@ export class LiveSessionOauthTokenSelectHandler {
                 sevenDayUtilization: snapshot.sevenDayUtilization,
                 sevenDayReset: snapshot.sevenDayReset,
               },
+        subscriptionDisabled: snapshot?.subscriptionDisabled ?? false,
+        unifiedRejected: snapshot?.unifiedRejected ?? false,
       };
     });

package/src/adapter/entry-points/handlers/OauthTokenSelectHandler.test.ts CHANGED Viewed

@@ -78,6 +78,28 @@ describe('OauthTokenSelectHandler', () => {
     );
   };
+  const writeSubscriptionDisabledCache = (
+    token: string,
+    epochSeconds: number = Date.now() / 1000,
+  ): void => {
+    const payload = { subscriptionDisabledEpoch: epochSeconds };
+    fs.writeFileSync(
+      path.join(cacheDirectory, `${hashToken(token)}.json`),
+      JSON.stringify(payload),
+    );
+  };
+  const writeCacheWithHeaders = (
+    token: string,
+    headers: Record<string, string>,
+  ): void => {
+    const payload = { ts: NOW, headers, modelWeeklyLimits: {} };
+    fs.writeFileSync(
+      path.join(cacheDirectory, `${hashToken(token)}.json`),
+      JSON.stringify(payload),
+    );
+  };
   it('selects the eligible token with the soonest 7d reset', () => {
     writeTokenList([
       { name: 'far', token: 'fake-far' },
@@ -168,6 +190,115 @@ describe('OauthTokenSelectHandler', () => {
     expect(output.diagnostics.join('\n')).toContain('No usable token entries');
   });
+  it('excludes a subscription-disabled token even when rate limits are fully free', () => {
+    writeTokenList([
+      { name: 'disabled', token: 'fake-disabled' },
+      { name: 'active', token: 'fake-active' },
+    ]);
+    writeSubscriptionDisabledCache('fake-disabled');
+    writeCache('fake-active', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+    const handler = new OauthTokenSelectHandler();
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('active');
+    expect(output.diagnostics.join('\n')).toContain(
+      'organization has disabled Claude subscription access for Claude Code',
+    );
+  });
+  it('excludes a unified-rejected token even when rate limits are fully free', () => {
+    writeTokenList([
+      { name: 'rejected', token: 'fake-rejected' },
+      { name: 'active', token: 'fake-active' },
+    ]);
+    writeCacheWithHeaders('fake-rejected', {
+      'anthropic-ratelimit-unified-status': 'rejected',
+      'anthropic-ratelimit-unified-5h-status': 'allowed',
+      'anthropic-ratelimit-unified-5h-reset': String(NOW + HOUR),
+      'anthropic-ratelimit-unified-5h-utilization': '0.1',
+      'anthropic-ratelimit-unified-7d-status': 'allowed',
+      'anthropic-ratelimit-unified-7d-reset': String(NOW + DAY),
+      'anthropic-ratelimit-unified-7d-utilization': '0.1',
+    });
+    writeCache('fake-active', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+    const handler = new OauthTokenSelectHandler();
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('active');
+    expect(output.diagnostics.join('\n')).toContain('rejected');
+  });
+  it('does not exclude a token solely because overage is disabled', () => {
+    writeTokenList([{ name: 'overage', token: 'fake-overage' }]);
+    writeCacheWithHeaders('fake-overage', {
+      'anthropic-ratelimit-unified-status': 'allowed',
+      'anthropic-ratelimit-unified-overage-disabled-reason': 'org_disabled',
+      'anthropic-ratelimit-unified-5h-status': 'allowed',
+      'anthropic-ratelimit-unified-5h-reset': String(NOW + HOUR),
+      'anthropic-ratelimit-unified-5h-utilization': '0.1',
+      'anthropic-ratelimit-unified-7d-status': 'allowed',
+      'anthropic-ratelimit-unified-7d-reset': String(NOW + DAY),
+      'anthropic-ratelimit-unified-7d-utilization': '0.1',
+    });
+    const handler = new OauthTokenSelectHandler();
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('overage');
+    expect(output.selectedToken).toBe('fake-overage');
+  });
+  it('returns null when every token is unusable (subscription-disabled or rejected)', () => {
+    writeTokenList([
+      { name: 'disabled', token: 'fake-disabled' },
+      { name: 'rejected', token: 'fake-rejected' },
+    ]);
+    writeSubscriptionDisabledCache('fake-disabled');
+    writeCacheWithHeaders('fake-rejected', {
+      'anthropic-ratelimit-unified-status': 'rejected',
+      'anthropic-ratelimit-unified-5h-status': 'allowed',
+      'anthropic-ratelimit-unified-5h-reset': String(NOW + HOUR),
+      'anthropic-ratelimit-unified-5h-utilization': '0.1',
+      'anthropic-ratelimit-unified-7d-status': 'allowed',
+      'anthropic-ratelimit-unified-7d-reset': String(NOW + DAY),
+      'anthropic-ratelimit-unified-7d-utilization': '0.1',
+    });
+    const handler = new OauthTokenSelectHandler();
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedToken).toBeNull();
+    expect(output.selectedName).toBeNull();
+  });
   describe('resolveTokenListJsonPath', () => {
     it('prefers the explicit path over the environment variable', () => {
       process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH = '/from/env.json';

package/src/adapter/entry-points/handlers/OauthTokenSelectHandler.ts CHANGED Viewed

@@ -93,6 +93,8 @@ export class OauthTokenSelectHandler {
                 sevenDayUtilization: snapshot.sevenDayUtilization,
                 sevenDayReset: snapshot.sevenDayReset,
               },
+        subscriptionDisabled: snapshot?.subscriptionDisabled ?? false,
+        unifiedRejected: snapshot?.unifiedRejected ?? false,
       };
     });