import { refreshVisibleToolsEffectiveForCurrentSession } from "../controllers/agents.ts";

import { loadSessions } from "../controllers/sessions.ts";

import { pushUniqueTrimmedSelectOption } from "../select-options.ts";

import { isCronSessionKey, resolveSessionDisplayName } from "../session-display.ts";

import {

buildAgentMainSessionKey,

isSubagentSessionKey,

}

}

/* Channel display labels. */

const CHANNEL_LABELS: Record<string, string> = {

imessage: "iMessage",

telegram: "Telegram",

discord: "Discord",

signal: "Signal",

slack: "Slack",

whatsapp: "WhatsApp",

matrix: "Matrix",

email: "Email",

sms: "SMS",

};

const KNOWN_CHANNEL_KEYS = Object.keys(CHANNEL_LABELS);

/** Parsed type / context extracted from a session key. */

export type SessionKeyInfo = {

/** Prefix for typed sessions (Subagent:/Cron:). Empty for others. */

prefix: string;

/** Human-readable fallback when no label / displayName is available. */

fallbackName: string;

};

function capitalize(s: string): string {

return s.charAt(0).toUpperCase() + s.slice(1);

}

/**

* Parse a session key to extract type information and a human-readable

* fallback display name. Exported for testing.

*/

export function parseSessionKey(key: string): SessionKeyInfo {

const normalized = normalizeLowercaseStringOrEmpty(key);

// Main session.

if (key === "main" || key === "agent:main:main") {

return { prefix: "", fallbackName: "Main Session" };

}

// Subagent.

if (key.includes(":subagent:")) {

return { prefix: "Subagent:", fallbackName: "Subagent:" };

}

// Cron job.

if (normalized.startsWith("cron:") || key.includes(":cron:")) {

return { prefix: "Cron:", fallbackName: "Cron Job:" };

}

// Direct chat: agent:<x>:<channel>:direct:<id>.

const directMatch = key.match(/^agent:[^:]+:([^:]+):direct:(.+)$/);

if (directMatch) {

const channel = directMatch[1];

const identifier = directMatch[2];

const channelLabel = CHANNEL_LABELS[channel] ?? capitalize(channel);

return { prefix: "", fallbackName: `${channelLabel} · ${identifier}` };

}

// Group chat: agent:<x>:<channel>:group:<id>.

const groupMatch = key.match(/^agent:[^:]+:([^:]+):group:(.+)$/);

if (groupMatch) {

const channel = groupMatch[1];

const channelLabel = CHANNEL_LABELS[channel] ?? capitalize(channel);

return { prefix: "", fallbackName: `${channelLabel} Group` };

}

// Channel-prefixed legacy keys, for example "imessage:g-...".

for (const ch of KNOWN_CHANNEL_KEYS) {

if (key === ch || key.startsWith(`${ch}:`)) {

return { prefix: "", fallbackName: `${CHANNEL_LABELS[ch]} Session` };

}

}

// Unknown: return key as-is.

return { prefix: "", fallbackName: key };

}

export function resolveSessionDisplayName(

key: string,

row?: SessionsListResult["sessions"][number],

): string {

const label = normalizeOptionalString(row?.label) ?? "";

const displayName = normalizeOptionalString(row?.displayName) ?? "";

const { prefix, fallbackName } = parseSessionKey(key);

const applyTypedPrefix = (name: string): string => {

if (!prefix) {

return name;

}

const prefixPattern = new RegExp(`^${prefix.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")}\\s*`, "i");

return prefixPattern.test(name) ? name : `${prefix} ${name}`;

};

if (label && label !== key) {

return applyTypedPrefix(label);

}

if (displayName && displayName !== key) {

return applyTypedPrefix(displayName);

}

return fallbackName;

}

export function isCronSessionKey(key: string): boolean {

const normalized = normalizeLowercaseStringOrEmpty(key);

if (!normalized) {

return false;

}

if (normalized.startsWith("cron:")) {

return true;

}

if (!normalized.startsWith("agent:")) {

return false;

}

const parts = normalized.split(":").filter(Boolean);

if (parts.length < 3) {

return false;

}

const rest = parts.slice(2).join(":");

return rest.startsWith("cron:");

}

type SessionOptionEntry = {

key: string;

label: string;