github-issue-tower-defence-management 1.104.3 → 1.105.0

package/src/domain/usecases/dashboard/GenerateDashboardRowUseCase.test.ts

@@ -0,0 +1,159 @@
+import { Issue } from '../../entities/Issue';
+import { GenerateDashboardRowUseCase } from './GenerateDashboardRowUseCase';
+
+const ASSIGNEE = 'HiromiShikata';
+
+let issueCounter = 0;
+const makeIssue = (overrides: Partial<Issue>): Issue => {
+  issueCounter += 1;
+  return {
+    nameWithOwner: 'demo/repo',
+    number: issueCounter,
+    title: `Issue ${issueCounter}`,
+    state: 'OPEN',
+    status: null,
+    story: null,
+    nextActionDate: null,
+    nextActionHour: null,
+    estimationMinutes: null,
+    dependedIssueUrls: [],
+    completionDate50PercentConfidence: null,
+    url: `https://github.com/demo/repo/issues/${issueCounter}`,
+    assignees: [ASSIGNEE],
+    labels: [],
+    org: 'demo',
+    repo: 'repo',
+    body: '',
+    itemId: `item-${issueCounter}`,
+    isPr: false,
+    isInProgress: false,
+    isClosed: false,
+    createdAt: new Date('2026-06-13T08:18:45.000Z'),
+    author: 'someone',
+    closingIssueReferenceUrls: [],
+    ...overrides,
+  };
+};
+
+describe('GenerateDashboardRowUseCase', () => {
+  const usecase = new GenerateDashboardRowUseCase();
+
+  beforeEach(() => {
+    issueCounter = 0;
+  });
+
+  it('returns all-zero counts for an empty issue list', () => {
+    expect(usecase.run({ issues: [], assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 0,
+      todo: 0,
+      qc: 0,
+      fail: 0,
+      pr: 0,
+      ws: 0,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('counts actionable Unread, Todo, Awaiting Quality Check and Awaiting Workspace issues', () => {
+    const issues = [
+      makeIssue({ status: 'Unread' }),
+      makeIssue({ status: 'Todo by human' }),
+      makeIssue({ status: 'Awaiting Quality Check' }),
+      makeIssue({ status: 'Awaiting Workspace' }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 1,
+      todo: 1,
+      qc: 1,
+      fail: 0,
+      pr: 0,
+      ws: 1,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('excludes non-actionable issues from actionable status columns', () => {
+    const issues = [
+      makeIssue({ status: 'Unread', nextActionDate: new Date() }),
+      makeIssue({ status: 'Unread', nextActionHour: 9 }),
+      makeIssue({
+        status: 'Awaiting Quality Check',
+        dependedIssueUrls: ['https://github.com/demo/repo/issues/999'],
+      }),
+      makeIssue({ status: 'Todo by human', assignees: ['someone-else'] }),
+      makeIssue({ status: 'Awaiting Workspace', isClosed: true }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 0,
+      todo: 0,
+      qc: 0,
+      fail: 0,
+      pr: 0,
+      ws: 0,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('counts Preparation and Failed Preparation by whole status without the actionable predicate', () => {
+    const issues = [
+      makeIssue({ status: 'Preparation', nextActionHour: 9 }),
+      makeIssue({
+        status: 'Failed Preparation',
+        dependedIssueUrls: ['https://github.com/demo/repo/issues/999'],
+      }),
+      makeIssue({ status: 'Preparation', isClosed: true }),
+      makeIssue({ status: 'Failed Preparation', assignees: ['someone-else'] }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 0,
+      todo: 0,
+      qc: 0,
+      fail: 1,
+      pr: 1,
+      ws: 0,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('counts dep as Awaiting Workspace issues blocked by a dependency, and never as ws', () => {
+    const issues = [
+      makeIssue({ status: 'Awaiting Workspace' }),
+      makeIssue({
+        status: 'Awaiting Workspace',
+        dependedIssueUrls: ['https://github.com/demo/repo/issues/999'],
+      }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toMatchObject({
+      ws: 1,
+      dep: 1,
+    });
+  });
+
+  it('counts blocker by case-insensitive workflow blocker story membership for non-closed mine issues', () => {
+    const issues = [
+      makeIssue({ status: 'Unread', story: 'Workflow Blocker / urgent' }),
+      makeIssue({ status: 'Awaiting Workspace', story: 'workflow blocker' }),
+      makeIssue({ status: 'Unread', story: 'regular / maintenance' }),
+      makeIssue({
+        status: 'Unread',
+        story: 'workflow blocker',
+        isClosed: true,
+      }),
+      makeIssue({
+        status: 'Unread',
+        story: 'workflow blocker',
+        assignees: ['someone-else'],
+      }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE }).blocker).toBe(2);
+  });
+});

package/src/domain/usecases/dashboard/GenerateDashboardRowUseCase.ts

@@ -0,0 +1,72 @@
+import { Issue } from '../../entities/Issue';
+import {
+  AWAITING_QUALITY_CHECK_STATUS_NAME,
+  AWAITING_WORKSPACE_STATUS_NAME,
+  DEFAULT_STATUS_NAME,
+  FAILED_PREPARATION_STATUS_NAME,
+  PREPARATION_STATUS_NAME,
+  TODO_STATUS_NAME,
+} from '../../entities/WorkflowStatus';
+
+export type DashboardRow = {
+  unread: number;
+  todo: number;
+  qc: number;
+  fail: number;
+  pr: number;
+  ws: number;
+  dep: number;
+  blocker: number;
+};
+
+export type GenerateDashboardRowInput = {
+  issues: Issue[];
+  assigneeLogin: string;
+};
+
+const WORKFLOW_BLOCKER_STORY_MARKER = 'workflow blocker';
+
+export class GenerateDashboardRowUseCase {
+  run = (input: GenerateDashboardRowInput): DashboardRow => {
+    const { issues, assigneeLogin } = input;
+
+    const mine = (issue: Issue): boolean =>
+      issue.isClosed === false && issue.assignees.includes(assigneeLogin);
+
+    const actionable = (issue: Issue): boolean =>
+      mine(issue) &&
+      issue.dependedIssueUrls.length === 0 &&
+      issue.nextActionDate === null &&
+      issue.nextActionHour === null;
+
+    const countActionableWithStatus = (statusName: string): number =>
+      issues.filter((issue) => issue.status === statusName && actionable(issue))
+        .length;
+
+    const countMineWithStatus = (statusName: string): number =>
+      issues.filter((issue) => mine(issue) && issue.status === statusName)
+        .length;
+
+    return {
+      unread: countActionableWithStatus(DEFAULT_STATUS_NAME),
+      todo: countActionableWithStatus(TODO_STATUS_NAME),
+      qc: countActionableWithStatus(AWAITING_QUALITY_CHECK_STATUS_NAME),
+      fail: countMineWithStatus(FAILED_PREPARATION_STATUS_NAME),
+      pr: countMineWithStatus(PREPARATION_STATUS_NAME),
+      ws: countActionableWithStatus(AWAITING_WORKSPACE_STATUS_NAME),
+      dep: issues.filter(
+        (issue) =>
+          mine(issue) &&
+          issue.status === AWAITING_WORKSPACE_STATUS_NAME &&
+          issue.dependedIssueUrls.length > 0,
+      ).length,
+      blocker: issues.filter(
+        (issue) =>
+          mine(issue) &&
+          (issue.story ?? '')
+            .toLowerCase()
+            .includes(WORKFLOW_BLOCKER_STORY_MARKER),
+      ).length,
+    };
+  };
+}

package/src/domain/usecases/dashboard/GenerateTokenStatusUseCase.test.ts

@@ -0,0 +1,209 @@
+import {
+  GenerateTokenStatusUseCase,
+  TokenRateLimitDecision,
+  TokenRateLimitSnapshot,
+  judgeTokenColor,
+} from './GenerateTokenStatusUseCase';
+
+const usableDecision = (
+  overrides: Partial<TokenRateLimitDecision> = {},
+): TokenRateLimitDecision => ({
+  fiveHourUtilization: 0.1,
+  sevenDayUtilization: 0.1,
+  fiveHourRejected: false,
+  sevenDayRejected: false,
+  blocked: false,
+  unifiedStatus: 'allowed',
+  sevenDaySonnetRejected: false,
+  sevenDayOpusRejected: false,
+  partial: false,
+  ...overrides,
+});
+
+describe('judgeTokenColor', () => {
+  it('returns Y when there is no snapshot or the snapshot is partial', () => {
+    expect(judgeTokenColor(null)).toBe('Y');
+    expect(judgeTokenColor(usableDecision({ partial: true }))).toBe('Y');
+  });
+
+  it('returns G for a normal allowed low-utilization token', () => {
+    expect(judgeTokenColor(usableDecision())).toBe('G');
+  });
+
+  it('returns Y for high utilization while allowed', () => {
+    expect(judgeTokenColor(usableDecision({ fiveHourUtilization: 0.8 }))).toBe(
+      'Y',
+    );
+  });
+
+  it('keeps a token usable (G) when only Sonnet 7d is rejected but Opus is usable', () => {
+    expect(
+      judgeTokenColor(
+        usableDecision({
+          sevenDaySonnetRejected: true,
+          sevenDayOpusRejected: false,
+        }),
+      ),
+    ).toBe('G');
+  });
+
+  it('returns Y when Sonnet is rejected, Opus usable, and 7d utilization is high', () => {
+    expect(
+      judgeTokenColor(
+        usableDecision({
+          sevenDaySonnetRejected: true,
+          sevenDayOpusRejected: false,
+          sevenDayUtilization: 0.8,
+        }),
+      ),
+    ).toBe('Y');
+  });
+
+  it('returns K when both Sonnet and Opus 7d are rejected', () => {
+    expect(
+      judgeTokenColor(
+        usableDecision({
+          sevenDaySonnetRejected: true,
+          sevenDayOpusRejected: true,
+        }),
+      ),
+    ).toBe('K');
+  });
+
+  it('returns K when the general 7d window is rejected', () => {
+    expect(judgeTokenColor(usableDecision({ sevenDayRejected: true }))).toBe(
+      'K',
+    );
+  });
+
+  it('returns K when the 5h window is rejected', () => {
+    expect(judgeTokenColor(usableDecision({ fiveHourRejected: true }))).toBe(
+      'K',
+    );
+  });
+
+  it('returns K when 5h utilization is exhausted', () => {
+    expect(judgeTokenColor(usableDecision({ fiveHourUtilization: 1.0 }))).toBe(
+      'K',
+    );
+  });
+
+  it('returns Y for the allowed_warning unified status', () => {
+    expect(
+      judgeTokenColor(usableDecision({ unifiedStatus: 'allowed_warning' })),
+    ).toBe('Y');
+  });
+});
+
+const snapshot = (
+  overrides: Partial<TokenRateLimitSnapshot> = {},
+): TokenRateLimitSnapshot => ({
+  fiveHourUtilization: 0.1,
+  fiveHourReset: 0,
+  sevenDayUtilization: 0.1,
+  sevenDayReset: 0,
+  blocked: false,
+  fiveHourRejected: false,
+  sevenDayRejected: false,
+  unifiedStatus: 'allowed',
+  sevenDaySonnetRejected: false,
+  sevenDayOpusRejected: false,
+  hasWindowData: true,
+  ...overrides,
+});
+
+describe('GenerateTokenStatusUseCase', () => {
+  const usecase = new GenerateTokenStatusUseCase();
+  const now = 1_000_000;
+
+  it('renders per-token utilization percents, color, prep and hum counts', () => {
+    const result = usecase.run({
+      tokens: [
+        {
+          name: 'alice',
+          token: 'token-a',
+          snapshot: snapshot({
+            fiveHourUtilization: 0.42,
+            fiveHourReset: now + 3600,
+            sevenDayUtilization: 0.8,
+            sevenDayReset: now + 86400,
+          }),
+        },
+        { name: 'bob', token: 'token-b', snapshot: null },
+      ],
+      prepCountByToken: new Map([['token-a', 2]]),
+      humCountByToken: new Map([['token-a', 1]]),
+      nowEpochSeconds: now,
+    });
+
+    expect(result).toEqual([
+      {
+        name: 'alice',
+        fiveHourUtilizationPercent: 42,
+        fiveHourResetSeconds: 3600,
+        sevenDayUtilizationPercent: 80,
+        sevenDayResetSeconds: 86400,
+        color: 'Y',
+        prep: 2,
+        hum: 1,
+      },
+      {
+        name: 'bob',
+        fiveHourUtilizationPercent: null,
+        fiveHourResetSeconds: null,
+        sevenDayUtilizationPercent: null,
+        sevenDayResetSeconds: null,
+        color: 'Y',
+        prep: 0,
+        hum: 0,
+      },
+    ]);
+  });
+
+  it('reports G for an allowed token with headroom on both windows', () => {
+    const result = usecase.run({
+      tokens: [
+        {
+          name: 'alice',
+          token: 'token-a',
+          snapshot: snapshot({
+            fiveHourUtilization: 0.1,
+            fiveHourReset: now + 3600,
+            sevenDayUtilization: 0.1,
+            sevenDayReset: now + 86400,
+          }),
+        },
+      ],
+      prepCountByToken: new Map(),
+      humCountByToken: new Map(),
+      nowEpochSeconds: now,
+    });
+
+    expect(result[0].color).toBe('G');
+  });
+
+  it('zeroes a window whose reset is already in the past and clears its rejection', () => {
+    const result = usecase.run({
+      tokens: [
+        {
+          name: 'alice',
+          token: 'token-a',
+          snapshot: snapshot({
+            fiveHourUtilization: 1.0,
+            fiveHourReset: now - 10,
+            fiveHourRejected: true,
+            sevenDayUtilization: 0.2,
+            sevenDayReset: now + 86400,
+          }),
+        },
+      ],
+      prepCountByToken: new Map(),
+      humCountByToken: new Map(),
+      nowEpochSeconds: now,
+    });
+
+    expect(result[0].fiveHourUtilizationPercent).toBe(0);
+    expect(result[0].fiveHourResetSeconds).toBe(0);
+    expect(result[0].color).toBe('G');
+  });
+});

package/src/domain/usecases/dashboard/GenerateTokenStatusUseCase.ts

@@ -0,0 +1,195 @@
+export type TokenStatusColor = 'G' | 'Y' | 'K';
+
+export type TokenRateLimitSnapshot = {
+  fiveHourUtilization: number;
+  fiveHourReset: number;
+  sevenDayUtilization: number;
+  sevenDayReset: number;
+  blocked: boolean;
+  fiveHourRejected: boolean;
+  sevenDayRejected: boolean;
+  unifiedStatus: string | null;
+  sevenDaySonnetRejected: boolean;
+  sevenDayOpusRejected: boolean;
+  hasWindowData: boolean;
+};
+
+export type TokenRateLimitDecision = {
+  fiveHourUtilization: number | null;
+  sevenDayUtilization: number | null;
+  fiveHourRejected: boolean;
+  sevenDayRejected: boolean;
+  blocked: boolean;
+  unifiedStatus: string | null;
+  sevenDaySonnetRejected: boolean;
+  sevenDayOpusRejected: boolean;
+  partial: boolean;
+};
+
+export type TokenStatus = {
+  name: string;
+  fiveHourUtilizationPercent: number | null;
+  fiveHourResetSeconds: number | null;
+  sevenDayUtilizationPercent: number | null;
+  sevenDayResetSeconds: number | null;
+  color: TokenStatusColor;
+  prep: number;
+  hum: number;
+};
+
+export type TokenStatusInput = {
+  name: string;
+  token: string;
+  snapshot: TokenRateLimitSnapshot | null;
+};
+
+export type GenerateTokenStatusInput = {
+  tokens: TokenStatusInput[];
+  prepCountByToken: Map<string, number>;
+  humCountByToken: Map<string, number>;
+  nowEpochSeconds: number;
+};
+
+const HIGH_UTILIZATION_THRESHOLD = 0.7;
+const ALLOWED_WARNING_STATUS = 'allowed_warning';
+
+export const judgeTokenColor = (
+  decision: TokenRateLimitDecision | null,
+): TokenStatusColor => {
+  if (decision === null || decision.partial) {
+    return 'Y';
+  }
+  const fiveHourUtilization = decision.fiveHourUtilization ?? 0;
+  const sevenDayUtilization = decision.sevenDayUtilization ?? 0;
+  const fiveHourExhausted =
+    fiveHourUtilization >= 1.0 || decision.fiveHourRejected;
+  const generalSevenDayRejected = decision.sevenDayRejected;
+  const bothModelsSevenDayRejected =
+    decision.sevenDaySonnetRejected && decision.sevenDayOpusRejected;
+  const noModelUsable =
+    decision.blocked ||
+    fiveHourExhausted ||
+    generalSevenDayRejected ||
+    bothModelsSevenDayRejected;
+  if (noModelUsable) {
+    return 'K';
+  }
+  if (decision.unifiedStatus === ALLOWED_WARNING_STATUS) {
+    return 'Y';
+  }
+  if (
+    fiveHourUtilization >= HIGH_UTILIZATION_THRESHOLD ||
+    sevenDayUtilization >= HIGH_UTILIZATION_THRESHOLD
+  ) {
+    return 'Y';
+  }
+  return 'G';
+};
+
+export class GenerateTokenStatusUseCase {
+  run = (input: GenerateTokenStatusInput): TokenStatus[] => {
+    const { tokens, prepCountByToken, humCountByToken, nowEpochSeconds } =
+      input;
+    return tokens.map((tokenInput) => {
+      const decision = this.toDecision(tokenInput.snapshot, nowEpochSeconds);
+      const normalized = this.normalizeWindows(
+        tokenInput.snapshot,
+        nowEpochSeconds,
+      );
+      return {
+        name: tokenInput.name,
+        fiveHourUtilizationPercent: normalized.fiveHourUtilizationPercent,
+        fiveHourResetSeconds: normalized.fiveHourResetSeconds,
+        sevenDayUtilizationPercent: normalized.sevenDayUtilizationPercent,
+        sevenDayResetSeconds: normalized.sevenDayResetSeconds,
+        color: judgeTokenColor(decision),
+        prep: prepCountByToken.get(tokenInput.token) ?? 0,
+        hum: humCountByToken.get(tokenInput.token) ?? 0,
+      };
+    });
+  };
+
+  private normalizeWindows = (
+    snapshot: TokenRateLimitSnapshot | null,
+    nowEpochSeconds: number,
+  ): {
+    fiveHourUtilizationPercent: number | null;
+    fiveHourResetSeconds: number | null;
+    sevenDayUtilizationPercent: number | null;
+    sevenDayResetSeconds: number | null;
+  } => {
+    if (snapshot === null || !snapshot.hasWindowData) {
+      return {
+        fiveHourUtilizationPercent: null,
+        fiveHourResetSeconds: null,
+        sevenDayUtilizationPercent: null,
+        sevenDayResetSeconds: null,
+      };
+    }
+    const fiveHourReset =
+      snapshot.fiveHourReset > 0 ? snapshot.fiveHourReset : null;
+    const sevenDayReset =
+      snapshot.sevenDayReset > 0 ? snapshot.sevenDayReset : null;
+    const fiveHourExpired =
+      fiveHourReset !== null && fiveHourReset < nowEpochSeconds;
+    const sevenDayExpired =
+      sevenDayReset !== null && sevenDayReset < nowEpochSeconds;
+    return {
+      fiveHourUtilizationPercent: fiveHourExpired
+        ? 0
+        : Math.trunc(snapshot.fiveHourUtilization * 100),
+      fiveHourResetSeconds:
+        fiveHourReset === null
+          ? null
+          : Math.max(0, fiveHourReset - nowEpochSeconds),
+      sevenDayUtilizationPercent: sevenDayExpired
+        ? 0
+        : Math.trunc(snapshot.sevenDayUtilization * 100),
+      sevenDayResetSeconds:
+        sevenDayReset === null
+          ? null
+          : Math.max(0, sevenDayReset - nowEpochSeconds),
+    };
+  };
+
+  private toDecision = (
+    snapshot: TokenRateLimitSnapshot | null,
+    nowEpochSeconds: number,
+  ): TokenRateLimitDecision | null => {
+    if (snapshot === null) {
+      return null;
+    }
+    if (!snapshot.hasWindowData) {
+      return {
+        fiveHourUtilization: null,
+        sevenDayUtilization: null,
+        fiveHourRejected: snapshot.fiveHourRejected,
+        sevenDayRejected: snapshot.sevenDayRejected,
+        blocked: snapshot.blocked,
+        unifiedStatus: snapshot.unifiedStatus,
+        sevenDaySonnetRejected: snapshot.sevenDaySonnetRejected,
+        sevenDayOpusRejected: snapshot.sevenDayOpusRejected,
+        partial: true,
+      };
+    }
+    const fiveHourExpired =
+      snapshot.fiveHourReset > 0 && snapshot.fiveHourReset < nowEpochSeconds;
+    const sevenDayExpired =
+      snapshot.sevenDayReset > 0 && snapshot.sevenDayReset < nowEpochSeconds;
+    return {
+      fiveHourUtilization: fiveHourExpired ? 0 : snapshot.fiveHourUtilization,
+      sevenDayUtilization: sevenDayExpired ? 0 : snapshot.sevenDayUtilization,
+      fiveHourRejected: fiveHourExpired ? false : snapshot.fiveHourRejected,
+      sevenDayRejected: sevenDayExpired ? false : snapshot.sevenDayRejected,
+      blocked: snapshot.blocked,
+      unifiedStatus: snapshot.unifiedStatus,
+      sevenDaySonnetRejected:
+        snapshot.sevenDaySonnetRejected ||
+        (sevenDayExpired ? false : snapshot.sevenDayRejected),
+      sevenDayOpusRejected:
+        snapshot.sevenDayOpusRejected ||
+        (sevenDayExpired ? false : snapshot.sevenDayRejected),
+      partial: false,
+    };
+  };
+}

package/types/adapter/entry-points/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/cli/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EACL,UAAU,EACV,cAAc,EACd,wBAAwB,EACxB,YAAY,EACZ,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AA+GzB,eAAO,MAAM,OAAO,SAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/cli/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EACL,UAAU,EACV,cAAc,EACd,wBAAwB,EACxB,YAAY,EACZ,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AA4GzB,eAAO,MAAM,OAAO,SAAgB,CAAC"}

package/types/adapter/entry-points/console/{consoleServer.d.ts → webServer.d.ts}

@@ -3,14 +3,14 @@ import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/Iss
 import { IssueTitleStateCache } from './consoleReadApi';
 import { ConsoleProjectResolver } from './consoleOperationApi';
 import { ImageFetcher } from './consoleImageProxy';
-export declare const DEFAULT_CONSOLE_PORT = 9981;
+export declare const DEFAULT_WEB_PORT = 9981;
 export declare const CONSOLE_TOKEN_HEADER = "x-pv-token";
 export declare const hasDotSegment: (requestPath: string) => boolean;
 export declare const requiresToken: (requestPath: string) => boolean;
 export declare const isConsoleAppRoute: (requestPath: string) => boolean;
 export declare const isTokenValid: (expectedToken: string, providedToken: string | null) => boolean;
 export declare const extractProvidedToken: (queryToken: string | string[] | null, headerToken: string | string[] | undefined) => string | null;
-export type ConsoleServerOptions = {
+export type WebServerOptions = {
     accessToken: string;
     uiDistDir: string;
     consoleDataOutputDir: string | null;
@@ -26,10 +26,10 @@ export declare const DASHBOARD_REQUEST_PATH = "/tdpm.txt";
 export declare const IMAGE_PROXY_REQUEST_PATH = "/api/img";
 export declare const resolveDashboardFilePath: (dashboardDir: string, requestPath: string) => string | null;
 export declare const resolveFlatInTmuxFilePath: (inTmuxDataDir: string, requestPath: string) => string | null;
-export declare const handleConsoleRequest: (options: ConsoleServerOptions, request: http.IncomingMessage, response: http.ServerResponse) => Promise<void>;
-export declare const createConsoleServer: (options: ConsoleServerOptions) => http.Server;
-export type StartConsoleServerOptions = ConsoleServerOptions & {
+export declare const handleWebRequest: (options: WebServerOptions, request: http.IncomingMessage, response: http.ServerResponse) => Promise<void>;
+export declare const createWebServer: (options: WebServerOptions) => http.Server;
+export type StartWebServerOptions = WebServerOptions & {
     port: number;
 };
-export declare const startConsoleServer: (options: StartConsoleServerOptions) => Promise<http.Server>;
-//# sourceMappingURL=consoleServer.d.ts.map
+export declare const startWebServer: (options: StartWebServerOptions) => Promise<http.Server>;
+//# sourceMappingURL=webServer.d.ts.map

package/types/adapter/entry-points/console/webServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webServer.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/console/webServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAG7B,OAAO,EAAE,eAAe,EAAE,MAAM,6DAA6D,CAAC;AAM9F,OAAO,EACL,oBAAoB,EAOrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAEL,sBAAsB,EAMvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAqB,MAAM,qBAAqB,CAAC;AAEtE,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAErC,eAAO,MAAM,oBAAoB,eAAe,CAAC;AAmCjD,eAAO,MAAM,aAAa,GAAI,aAAa,MAAM,KAAG,OAGiB,CAAC;AAEtE,eAAO,MAAM,aAAa,GAAI,aAAa,MAAM,KAAG,OAGrB,CAAC;AAIhC,eAAO,MAAM,iBAAiB,GAAI,aAAa,MAAM,KAAG,OAmBvD,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,eAAe,MAAM,EACrB,eAAe,MAAM,GAAG,IAAI,KAC3B,OAAoE,CAAC;AAExE,eAAO,MAAM,oBAAoB,GAC/B,YAAY,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,EACpC,aAAa,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,KACzC,MAAM,GAAG,IAQX,CAAC;AAuCF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IACzC,cAAc,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAC/C,oBAAoB,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;CACpD,CAAC;AAMF,eAAO,MAAM,sBAAsB,cAAc,CAAC;AAElD,eAAO,MAAM,wBAAwB,aAAa,CAAC;AAInD,eAAO,MAAM,wBAAwB,GACnC,cAAc,MAAM,EACpB,aAAa,MAAM,KAClB,MAAM,GAAG,IAWX,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,eAAe,MAAM,EACrB,aAAa,MAAM,KAClB,MAAM,GAAG,IAeX,CAAC;AA4TF,eAAO,MAAM,gBAAgB,GAC3B,SAAS,gBAAgB,EACzB,SAAS,IAAI,CAAC,eAAe,EAC7B,UAAU,IAAI,CAAC,cAAc,KAC5B,OAAO,CAAC,IAAI,CAiFd,CAAC;AAcF,eAAO,MAAM,eAAe,GAAI,SAAS,gBAAgB,KAAG,IAAI,CAAC,MAM7D,CAAC;AAEL,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG;IACrD,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,SAAS,qBAAqB,KAC7B,OAAO,CAAC,IAAI,CAAC,MAAM,CAQlB,CAAC"}

package/types/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AA8B3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,KAChB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CAyYP;CACH"}
+{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AA6BA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAgC3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,KAChB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CAwbP;CACH"}