@lumenflow/cli 5.5.0 → 5.7.12

package/packs/sidekick/tool-impl/channel-tools.ts

@@ -1,577 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import { getChannelTransport } from './channel-transports.js';
-import { getStoragePort, type ChannelMessageRecord, type ChannelRecord } from './storage.js';
-import {
-  asInteger,
-  asNonEmptyString,
-  buildAuditEvent,
-  createId,
-  failure,
-  isDryRun,
-  nowIso,
-  success,
-  toRecord,
-  type ToolContextLike,
-  type ToolOutput,
-} from './shared.js';
-import {
-  buildChannelBridgeConnectedEvent,
-  buildChannelBridgeDisconnectedEvent,
-  buildChannelMessageReceivedEvent,
-  buildChannelMessageSentEvent,
-  emitSidekickEvent,
-} from '../sidekick-events.js';
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const TOOL_NAMES = {
-  CONFIGURE: 'channel:configure',
-  LIST: 'channel:list',
-  DELETE: 'channel:delete',
-  SEND: 'channel:send',
-  RECEIVE: 'channel:receive',
-} as const;
-
-const OUTBOX_CAP = 100;
-const DEFAULT_CHANNEL_NAME = 'default';
-
-function asOptionalRecord(value: unknown): Record<string, unknown> | undefined {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    return undefined;
-  }
-  return value as Record<string, unknown>;
-}
-
-function withTransportMetadata<T extends Record<string, unknown>>(
-  data: T,
-  metadata: Record<string, unknown> | undefined,
-): T & Record<string, unknown> {
-  if (!metadata) {
-    return data;
-  }
-  return {
-    ...data,
-    metadata,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// channel:configure
-// ---------------------------------------------------------------------------
-
-async function channelConfigureTool(
-  input: unknown,
-  context?: ToolContextLike,
-): Promise<ToolOutput> {
-  const parsed = toRecord(input);
-  const name = asNonEmptyString(parsed.name);
-
-  if (!name) {
-    return failure('INVALID_INPUT', 'name is required.');
-  }
-
-  const now = nowIso();
-  const channel: ChannelRecord = {
-    id: createId('chan'),
-    name,
-    created_at: now,
-    updated_at: now,
-  };
-
-  if (isDryRun(parsed)) {
-    return success({
-      dry_run: true,
-      channel: channel as unknown as Record<string, unknown>,
-    });
-  }
-
-  const storage = getStoragePort();
-  let resolvedChannel = channel;
-
-  await storage.withLock(async () => {
-    const channels = await storage.readStore('channels');
-    const existing = channels.find((c) => c.name === name);
-
-    if (existing) {
-      resolvedChannel = { ...existing, updated_at: now };
-      const updated = channels.map((c) => (c.id === existing.id ? resolvedChannel : c));
-      await storage.writeStore('channels', updated);
-      await storage.appendAudit(
-        buildAuditEvent({
-          tool: TOOL_NAMES.CONFIGURE,
-          op: 'update',
-          context,
-          ids: [existing.id],
-        }),
-      );
-    } else {
-      channels.push(channel);
-      await storage.writeStore('channels', channels);
-      await storage.appendAudit(
-        buildAuditEvent({
-          tool: TOOL_NAMES.CONFIGURE,
-          op: 'create',
-          context,
-          ids: [channel.id],
-        }),
-      );
-    }
-  });
-
-  await emitSidekickEvent(buildChannelBridgeConnectedEvent(resolvedChannel));
-
-  return success({ channel: resolvedChannel as unknown as Record<string, unknown> });
-}
-
-// ---------------------------------------------------------------------------
-// channel:list
-// ---------------------------------------------------------------------------
-
-async function channelListTool(_input: unknown, _context?: ToolContextLike): Promise<ToolOutput> {
-  const storage = getStoragePort();
-  const channels = await storage.readStore('channels');
-  const messages = await storage.readStore('messages');
-
-  const items = channels
-    .map((channel) => {
-      const channelMessages = messages.filter((message) => message.channel_id === channel.id);
-      const lastMessage = channelMessages.toSorted(
-        (left, right) => Date.parse(right.created_at) - Date.parse(left.created_at),
-      )[0];
-
-      return {
-        ...channel,
-        message_count: channelMessages.length,
-        last_message_at: lastMessage?.created_at,
-      };
-    })
-    .toSorted((left, right) => {
-      const leftTs = left.last_message_at ?? left.updated_at;
-      const rightTs = right.last_message_at ?? right.updated_at;
-      return Date.parse(rightTs) - Date.parse(leftTs);
-    });
-
-  return success({
-    items: items as unknown as Record<string, unknown>,
-    count: items.length,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// channel:delete
-// ---------------------------------------------------------------------------
-
-async function channelDeleteTool(input: unknown, context?: ToolContextLike): Promise<ToolOutput> {
-  const parsed = toRecord(input);
-  const id = asNonEmptyString(parsed.id);
-
-  if (!id) {
-    return failure('INVALID_INPUT', 'id is required.');
-  }
-
-  const storage = getStoragePort();
-  const channels = await storage.readStore('channels');
-  const channel = channels.find((entry) => entry.id === id);
-
-  if (!channel) {
-    return failure('NOT_FOUND', `channel ${id} was not found.`);
-  }
-
-  const messages = await storage.readStore('messages');
-  const deletedMessages = messages.filter((message) => message.channel_id === id);
-
-  if (isDryRun(parsed)) {
-    return success({
-      dry_run: true,
-      deleted_id: id,
-      deleted_message_count: deletedMessages.length,
-    });
-  }
-
-  await storage.withLock(async () => {
-    const latestChannels = await storage.readStore('channels');
-    const latestMessages = await storage.readStore('messages');
-    await storage.writeStore(
-      'channels',
-      latestChannels.filter((entry) => entry.id !== id),
-    );
-    await storage.writeStore(
-      'messages',
-      latestMessages.filter((message) => message.channel_id !== id),
-    );
-    await storage.appendAudit(
-      buildAuditEvent({
-        tool: TOOL_NAMES.DELETE,
-        op: 'delete',
-        context,
-        ids: [id],
-        details: { deleted_message_count: deletedMessages.length },
-      }),
-    );
-  });
-
-  await emitSidekickEvent(
-    buildChannelBridgeDisconnectedEvent({
-      bridge_id: id,
-      deleted_message_count: deletedMessages.length,
-    }),
-  );
-
-  return success({
-    deleted_id: id,
-    deleted_message_count: deletedMessages.length,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// channel:send
-// ---------------------------------------------------------------------------
-
-async function channelSendViaTransport(
-  input: Record<string, unknown>,
-  context: ToolContextLike | undefined,
-  provider: string,
-  channel: string,
-  content: string,
-): Promise<ToolOutput> {
-  const workspaceId = asNonEmptyString(context?.workspace_id);
-  if (!workspaceId) {
-    return failure(
-      'WORKSPACE_CONTEXT_REQUIRED',
-      'workspace_id is required when provider is specified.',
-    );
-  }
-
-  const transport = getChannelTransport(provider);
-  if (!transport) {
-    return failure(
-      'INTEGRATION_PROVIDER_NOT_REGISTERED',
-      `No channel transport registered for provider: ${provider}`,
-    );
-  }
-
-  if (isDryRun(input)) {
-    return success({
-      dry_run: true,
-      provider,
-      capability: 'send',
-      channel,
-      content,
-    });
-  }
-
-  const transportResult = await transport.send({
-    workspaceId,
-    provider,
-    channel,
-    content,
-    metadata: asOptionalRecord(input.metadata),
-  });
-
-  const outputData = withTransportMetadata(
-    {
-      provider,
-      capability: 'send',
-      channel,
-      ...(transportResult.externalMessageId !== undefined
-        ? { externalMessageId: transportResult.externalMessageId }
-        : {}),
-      ...(transportResult.failureClass ? { failureClass: transportResult.failureClass } : {}),
-      ...(transportResult.retryAfterSeconds !== undefined
-        ? { retryAfterSeconds: transportResult.retryAfterSeconds }
-        : {}),
-    },
-    transportResult.metadata,
-  );
-
-  if (!transportResult.success) {
-    return {
-      success: false,
-      error: {
-        code: 'INTEGRATION_PROVIDER_SEND_FAILED',
-        message: transportResult.error ?? `Provider send failed for provider: ${provider}`,
-      },
-      data: outputData,
-    };
-  }
-
-  // WU-2830 (INIT-062 WU-D): ChannelMessageSentEvent.message is a typed
-  // ChannelMessageRecord. Provider sends do not have a local storage row,
-  // so we synthesize a record using the external id when available.
-  const providerSentMessage: ChannelMessageRecord = {
-    id: transportResult.externalMessageId ?? createId('msg'),
-    channel_id: `${provider}:${channel}`,
-    sender: 'assistant',
-    content,
-    created_at: nowIso(),
-  };
-
-  await emitSidekickEvent(buildChannelMessageSentEvent(providerSentMessage));
-
-  return success(outputData);
-}
-
-async function channelSendTool(input: unknown, context?: ToolContextLike): Promise<ToolOutput> {
-  const parsed = toRecord(input);
-  const content = asNonEmptyString(parsed.content);
-
-  if (!content) {
-    return failure('INVALID_INPUT', 'content is required.');
-  }
-
-  const channelName = asNonEmptyString(parsed.channel) ?? DEFAULT_CHANNEL_NAME;
-  const provider = asNonEmptyString(parsed.provider);
-
-  if (provider) {
-    return channelSendViaTransport(parsed, context, provider, channelName, content);
-  }
-
-  const sender = asNonEmptyString(parsed.sender) ?? 'assistant';
-  const now = nowIso();
-
-  const message: ChannelMessageRecord = {
-    id: createId('msg'),
-    channel_id: '', // resolved below
-    sender,
-    content,
-    created_at: now,
-  };
-
-  if (isDryRun(parsed)) {
-    return success({
-      dry_run: true,
-      message: { ...message, channel_id: 'dry-run' } as unknown as Record<string, unknown>,
-    });
-  }
-
-  const storage = getStoragePort();
-  let resolvedMessage = message;
-
-  await storage.withLock(async () => {
-    const channels = await storage.readStore('channels');
-    const found = channels.find((c) => c.name === channelName);
-    let channelId: string;
-
-    if (!found) {
-      channelId = createId('chan');
-      channels.push({
-        id: channelId,
-        name: channelName,
-        created_at: now,
-        updated_at: now,
-      });
-      await storage.writeStore('channels', channels);
-    } else {
-      channelId = found.id;
-      const updated = channels.map((c) => (c.id === channelId ? { ...c, updated_at: now } : c));
-      await storage.writeStore('channels', updated);
-    }
-
-    resolvedMessage = { ...message, channel_id: channelId };
-
-    const messages = await storage.readStore('messages');
-    messages.push(resolvedMessage);
-
-    // Cap outbox at OUTBOX_CAP
-    const capped = messages.length > OUTBOX_CAP ? messages.slice(-OUTBOX_CAP) : messages;
-    await storage.writeStore('messages', capped);
-
-    await storage.appendAudit(
-      buildAuditEvent({
-        tool: TOOL_NAMES.SEND,
-        op: 'create',
-        context,
-        ids: [channelId, resolvedMessage.id],
-      }),
-    );
-  });
-
-  // WU-2830: pass the typed ChannelMessageRecord directly.
-  await emitSidekickEvent(buildChannelMessageSentEvent(resolvedMessage));
-
-  return success({ message: resolvedMessage as unknown as Record<string, unknown> });
-}
-
-// ---------------------------------------------------------------------------
-// channel:receive
-// ---------------------------------------------------------------------------
-
-async function channelReceiveViaTransport(
-  input: Record<string, unknown>,
-  context: ToolContextLike | undefined,
-  provider: string,
-  channel: string,
-  limit: number | null,
-): Promise<ToolOutput> {
-  const workspaceId = asNonEmptyString(context?.workspace_id);
-  if (!workspaceId) {
-    return failure(
-      'WORKSPACE_CONTEXT_REQUIRED',
-      'workspace_id is required when provider is specified.',
-    );
-  }
-
-  const transport = getChannelTransport(provider);
-  if (!transport) {
-    return failure(
-      'INTEGRATION_PROVIDER_NOT_REGISTERED',
-      `No channel transport registered for provider: ${provider}`,
-    );
-  }
-
-  const cursor = asNonEmptyString(input.cursor) ?? undefined;
-
-  const transportResult = await transport.receive({
-    workspaceId,
-    provider,
-    channel,
-    cursor,
-    limit: limit && limit > 0 ? limit : undefined,
-    metadata: asOptionalRecord(input.metadata),
-  });
-
-  const outputData = withTransportMetadata(
-    {
-      provider,
-      capability: 'read',
-      channel,
-      ...(transportResult.records !== undefined ? { records: transportResult.records } : {}),
-      ...(transportResult.nextCursor !== undefined
-        ? { nextCursor: transportResult.nextCursor }
-        : {}),
-      ...(transportResult.failureClass ? { failureClass: transportResult.failureClass } : {}),
-      ...(transportResult.retryAfterSeconds !== undefined
-        ? { retryAfterSeconds: transportResult.retryAfterSeconds }
-        : {}),
-    },
-    transportResult.metadata,
-  );
-
-  if (!transportResult.success) {
-    return {
-      success: false,
-      error: {
-        code: 'INTEGRATION_PROVIDER_RECEIVE_FAILED',
-        message: transportResult.error ?? `Provider receive failed for provider: ${provider}`,
-      },
-      data: outputData,
-    };
-  }
-
-  // WU-2830: ChannelMessageReceivedEvent now carries typed
-  // ChannelMessageRecord[] (symmetric with the sent event). Coerce
-  // provider-opaque records into the canonical shape before emission.
-  const receivedRecords = (transportResult.records ?? []).map((record) =>
-    coerceProviderRecordToMessageRecord(record, `${provider}:${channel}`),
-  );
-
-  await emitSidekickEvent(
-    buildChannelMessageReceivedEvent({
-      provider,
-      channel,
-      messages: receivedRecords,
-    }),
-  );
-
-  return success(outputData);
-}
-
-function coerceProviderRecordToMessageRecord(
-  record: unknown,
-  fallbackChannelId: string,
-): ChannelMessageRecord {
-  // WU-2830: provider transports declare `records?: unknown[]`. Type-narrow
-  // to build a ChannelMessageRecord without unsafe casts; missing fields
-  // fall back to sensible defaults so downstream consumers always see a
-  // complete, typed payload.
-  const source = record && typeof record === 'object' ? (record as Record<string, unknown>) : {};
-  const now = nowIso();
-  const id = typeof source.id === 'string' && source.id.length > 0 ? source.id : createId('msg');
-  const channel_id =
-    typeof source.channel_id === 'string' && source.channel_id.length > 0
-      ? source.channel_id
-      : fallbackChannelId;
-  const sender =
-    typeof source.sender === 'string' && source.sender.length > 0 ? source.sender : 'external';
-  const content = typeof source.content === 'string' ? source.content : '';
-  const created_at =
-    typeof source.created_at === 'string' && source.created_at.length > 0 ? source.created_at : now;
-  return { id, channel_id, sender, content, created_at };
-}
-
-async function channelReceiveTool(input: unknown, _context?: ToolContextLike): Promise<ToolOutput> {
-  const parsed = toRecord(input);
-  const channelName = asNonEmptyString(parsed.channel);
-  const limit = asInteger(parsed.limit);
-  const provider = asNonEmptyString(parsed.provider);
-
-  if (provider) {
-    return channelReceiveViaTransport(
-      parsed,
-      _context,
-      provider,
-      channelName ?? DEFAULT_CHANNEL_NAME,
-      limit,
-    );
-  }
-
-  const storage = getStoragePort();
-  const messages = await storage.readStore('messages');
-  const channels = await storage.readStore('channels');
-
-  let filtered = messages;
-
-  if (channelName) {
-    const channel = channels.find((c) => c.name === channelName);
-    if (channel) {
-      filtered = messages.filter((m) => m.channel_id === channel.id);
-    } else {
-      filtered = [];
-    }
-  }
-
-  const sorted = filtered.toSorted((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
-
-  const items = limit && limit > 0 ? sorted.slice(-limit) : sorted;
-
-  await emitSidekickEvent(
-    buildChannelMessageReceivedEvent({
-      channel: channelName ?? DEFAULT_CHANNEL_NAME,
-      // WU-2830: carry the full typed ChannelMessageRecord[] payload.
-      messages: items,
-    }),
-  );
-
-  return success({
-    items: items as unknown as Record<string, unknown>,
-    count: items.length,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Router (default export)
-// ---------------------------------------------------------------------------
-
-export default async function channelTools(
-  input: unknown,
-  context?: ToolContextLike,
-): Promise<ToolOutput> {
-  switch (context?.tool_name) {
-    case TOOL_NAMES.CONFIGURE:
-      return channelConfigureTool(input, context);
-    case TOOL_NAMES.LIST:
-      return channelListTool(input, context);
-    case TOOL_NAMES.DELETE:
-      return channelDeleteTool(input, context);
-    case TOOL_NAMES.SEND:
-      return channelSendTool(input, context);
-    case TOOL_NAMES.RECEIVE:
-      return channelReceiveTool(input, context);
-    default:
-      return failure('UNKNOWN_TOOL', `Unknown channel tool: ${context?.tool_name ?? 'unknown'}`);
-  }
-}

package/packs/sidekick/tool-impl/channel-transports.ts

@@ -1,75 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import { getSidekickRuntimeContext } from './runtime-context.js';
-
-export interface ChannelTransport {
-  provider: string;
-  send(req: {
-    workspaceId: string;
-    provider: string;
-    channel: string;
-    content: string;
-    metadata?: Record<string, unknown>;
-  }): Promise<{
-    success: boolean;
-    error?: string;
-    externalMessageId?: string;
-    failureClass?: 'retryable' | 'terminal';
-    retryAfterSeconds?: number;
-    metadata?: Record<string, unknown>;
-  }>;
-  receive(req: {
-    workspaceId: string;
-    provider: string;
-    channel: string;
-    cursor?: string;
-    limit?: number;
-    metadata?: Record<string, unknown>;
-  }): Promise<{
-    success: boolean;
-    error?: string;
-    records?: unknown[];
-    nextCursor?: string;
-    failureClass?: 'retryable' | 'terminal';
-    retryAfterSeconds?: number;
-    metadata?: Record<string, unknown>;
-  }>;
-}
-
-function normalizeProvider(provider: string): string {
-  return provider.trim().toLowerCase();
-}
-
-function getRegistry(): Map<string, ChannelTransport> | undefined {
-  return getSidekickRuntimeContext()?.channelTransports;
-}
-
-export function registerChannelTransport(transport: ChannelTransport): void {
-  const provider = normalizeProvider(transport.provider);
-  if (provider.length === 0) {
-    throw new Error('channel transport provider must be a non-empty string.');
-  }
-  const registry = getRegistry();
-  if (!registry) {
-    throw new Error('channel transport registry is unavailable outside sidekick runtime context.');
-  }
-  registry.set(provider, transport);
-}
-
-export function getChannelTransport(provider: string): ChannelTransport | undefined {
-  const normalized = normalizeProvider(provider);
-  if (normalized.length === 0) {
-    return undefined;
-  }
-  const registry = getRegistry();
-  return registry?.get(normalized);
-}
-
-export function clearChannelTransports(): void {
-  const registry = getRegistry();
-  if (!registry) {
-    return;
-  }
-  registry.clear();
-}

package/packs/sidekick/tool-impl/index.ts

@@ -1,29 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-export {
-  type AuditEvent,
-  type ChannelMessageRecord,
-  type ChannelRecord,
-  type MemoryRecord,
-  type MemoryType,
-  type RoutineRecord,
-  type RoutineStepRecord,
-  type SidekickStores,
-  type StoragePort,
-  type StoreName,
-  type TaskPriority,
-  type TaskRecord,
-  type TaskStatus,
-  FsStoragePort,
-  getStoragePort,
-  runWithStoragePort,
-  setDefaultStoragePort,
-} from './storage.js';
-
-export {
-  type ChannelTransport,
-  clearChannelTransports,
-  getChannelTransport,
-  registerChannelTransport,
-} from './channel-transports.js';