@symerian/symi 3.0.20 → 3.0.21

package/extensions/line/src/runtime.ts

@@ -1,14 +0,0 @@
-import type { PluginRuntime } from "symi/plugin-sdk";
-
-let runtime: PluginRuntime | null = null;
-
-export function setLineRuntime(r: PluginRuntime): void {
-  runtime = r;
-}
-
-export function getLineRuntime(): PluginRuntime {
-  if (!runtime) {
-    throw new Error("LINE runtime not initialized - plugin not registered");
-  }
-  return runtime;
-}

package/extensions/line/symi.plugin.json

@@ -1,9 +0,0 @@
-{
-  "id": "line",
-  "channels": ["line"],
-  "configSchema": {
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {}
-  }
-}

package/extensions/signal/index.ts

@@ -1,17 +0,0 @@
-import type { SymiPluginApi } from "symi/plugin-sdk";
-import { emptyPluginConfigSchema } from "symi/plugin-sdk";
-import { signalPlugin } from "./src/channel.js";
-import { setSignalRuntime } from "./src/runtime.js";
-
-const plugin = {
-  id: "signal",
-  name: "Signal",
-  description: "Signal channel plugin",
-  configSchema: emptyPluginConfigSchema(),
-  register(api: SymiPluginApi) {
-    setSignalRuntime(api.runtime);
-    api.registerChannel({ plugin: signalPlugin });
-  },
-};
-
-export default plugin;

package/extensions/signal/node_modules/.bin/symi

@@ -1,21 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*)
-        if command -v cygpath > /dev/null 2>&1; then
-            basedir=`cygpath -w "$basedir"`
-        fi
-    ;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/home/symi/projects/symi/node_modules:/home/symi/projects/node_modules:/home/symi/node_modules:/home/node_modules:/node_modules:/home/symi/projects/symi/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/home/symi/projects/symi/node_modules:/home/symi/projects/node_modules:/home/symi/node_modules:/home/node_modules:/node_modules:/home/symi/projects/symi/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../@symerian/symi/symi.mjs" "$@"
-else
-  exec node  "$basedir/../@symerian/symi/symi.mjs" "$@"
-fi

package/extensions/signal/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "@symi/signal",
-  "version": "3.0.9",
-  "private": true,
-  "description": "Symi Signal channel plugin",
-  "type": "module",
-  "devDependencies": {
-    "@symerian/symi": "workspace:*"
-  },
-  "symi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  }
-}

package/extensions/signal/src/channel.ts

@@ -1,302 +0,0 @@
-import {
-  applyAccountNameToChannelSection,
-  buildBaseChannelStatusSummary,
-  buildChannelConfigSchema,
-  collectStatusIssuesFromLastError,
-  createDefaultChannelRuntimeState,
-  DEFAULT_ACCOUNT_ID,
-  deleteAccountFromConfigSection,
-  formatPairingApproveHint,
-  getChatChannelMeta,
-  listSignalAccountIds,
-  looksLikeSignalTargetId,
-  migrateBaseNameToDefaultAccount,
-  normalizeAccountId,
-  normalizeE164,
-  normalizeSignalMessagingTarget,
-  PAIRING_APPROVED_MESSAGE,
-  resolveChannelMediaMaxBytes,
-  resolveDefaultSignalAccountId,
-  resolveSignalAccount,
-  setAccountEnabledInConfigSection,
-  signalOnboardingAdapter,
-  SignalConfigSchema,
-  type ChannelMessageActionAdapter,
-  type ChannelPlugin,
-  type ResolvedSignalAccount,
-} from "symi/plugin-sdk";
-import { getSignalRuntime } from "./runtime.js";
-
-const signalMessageActions: ChannelMessageActionAdapter = {
-  listActions: (ctx) => getSignalRuntime().channel.signal.messageActions?.listActions?.(ctx) ?? [],
-  supportsAction: (ctx) =>
-    getSignalRuntime().channel.signal.messageActions?.supportsAction?.(ctx) ?? false,
-  handleAction: async (ctx) => {
-    const ma = getSignalRuntime().channel.signal.messageActions;
-    if (!ma?.handleAction) {
-      throw new Error("Signal message actions not available");
-    }
-    return ma.handleAction(ctx);
-  },
-};
-
-const meta = getChatChannelMeta("signal");
-
-export const signalPlugin: ChannelPlugin<ResolvedSignalAccount> = {
-  id: "signal",
-  meta: {
-    ...meta,
-  },
-  onboarding: signalOnboardingAdapter,
-  pairing: {
-    idLabel: "signalNumber",
-    normalizeAllowEntry: (entry) => entry.replace(/^signal:/i, ""),
-    notifyApproval: async ({ id }) => {
-      await getSignalRuntime().channel.signal.sendMessageSignal(id, PAIRING_APPROVED_MESSAGE);
-    },
-  },
-  capabilities: {
-    chatTypes: ["direct", "group"],
-    media: true,
-    reactions: true,
-  },
-  actions: signalMessageActions,
-  streaming: {
-    blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
-  },
-  reload: { configPrefixes: ["channels.signal"] },
-  configSchema: buildChannelConfigSchema(SignalConfigSchema),
-  config: {
-    listAccountIds: (cfg) => listSignalAccountIds(cfg),
-    resolveAccount: (cfg, accountId) => resolveSignalAccount({ cfg, accountId }),
-    defaultAccountId: (cfg) => resolveDefaultSignalAccountId(cfg),
-    setAccountEnabled: ({ cfg, accountId, enabled }) =>
-      setAccountEnabledInConfigSection({
-        cfg,
-        sectionKey: "signal",
-        accountId,
-        enabled,
-        allowTopLevel: true,
-      }),
-    deleteAccount: ({ cfg, accountId }) =>
-      deleteAccountFromConfigSection({
-        cfg,
-        sectionKey: "signal",
-        accountId,
-        clearBaseFields: ["account", "httpUrl", "httpHost", "httpPort", "cliPath", "name"],
-      }),
-    isConfigured: (account) => account.configured,
-    describeAccount: (account) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      baseUrl: account.baseUrl,
-    }),
-    resolveAllowFrom: ({ cfg, accountId }) =>
-      (resolveSignalAccount({ cfg, accountId }).config.allowFrom ?? []).map((entry) =>
-        String(entry),
-      ),
-    formatAllowFrom: ({ allowFrom }) =>
-      allowFrom
-        .map((entry) => String(entry).trim())
-        .filter(Boolean)
-        .map((entry) => (entry === "*" ? "*" : normalizeE164(entry.replace(/^signal:/i, ""))))
-        .filter(Boolean),
-    resolveDefaultTo: ({ cfg, accountId }) =>
-      resolveSignalAccount({ cfg, accountId }).config.defaultTo?.trim() || undefined,
-  },
-  security: {
-    resolveDmPolicy: ({ cfg, accountId, account }) => {
-      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
-      const useAccountPath = Boolean(cfg.channels?.signal?.accounts?.[resolvedAccountId]);
-      const basePath = useAccountPath
-        ? `channels.signal.accounts.${resolvedAccountId}.`
-        : "channels.signal.";
-      return {
-        policy: account.config.dmPolicy ?? "pairing",
-        allowFrom: account.config.allowFrom ?? [],
-        policyPath: `${basePath}dmPolicy`,
-        allowFromPath: basePath,
-        approveHint: formatPairingApproveHint("signal"),
-        normalizeEntry: (raw) => normalizeE164(raw.replace(/^signal:/i, "").trim()),
-      };
-    },
-    collectWarnings: ({ account, cfg }) => {
-      const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-      const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
-      if (groupPolicy !== "open") {
-        return [];
-      }
-      return [
-        `- Signal groups: groupPolicy="open" allows any member to trigger the bot. Set channels.signal.groupPolicy="allowlist" + channels.signal.groupAllowFrom to restrict senders.`,
-      ];
-    },
-  },
-  messaging: {
-    normalizeTarget: normalizeSignalMessagingTarget,
-    targetResolver: {
-      looksLikeId: looksLikeSignalTargetId,
-      hint: "<E.164|uuid:ID|group:ID|signal:group:ID|signal:+E.164>",
-    },
-  },
-  setup: {
-    resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
-    applyAccountName: ({ cfg, accountId, name }) =>
-      applyAccountNameToChannelSection({
-        cfg,
-        channelKey: "signal",
-        accountId,
-        name,
-      }),
-    validateInput: ({ input }) => {
-      if (
-        !input.signalNumber &&
-        !input.httpUrl &&
-        !input.httpHost &&
-        !input.httpPort &&
-        !input.cliPath
-      ) {
-        return "Signal requires --signal-number or --http-url/--http-host/--http-port/--cli-path.";
-      }
-      return null;
-    },
-    applyAccountConfig: ({ cfg, accountId, input }) => {
-      const namedConfig = applyAccountNameToChannelSection({
-        cfg,
-        channelKey: "signal",
-        accountId,
-        name: input.name,
-      });
-      const next =
-        accountId !== DEFAULT_ACCOUNT_ID
-          ? migrateBaseNameToDefaultAccount({
-              cfg: namedConfig,
-              channelKey: "signal",
-            })
-          : namedConfig;
-      if (accountId === DEFAULT_ACCOUNT_ID) {
-        return {
-          ...next,
-          channels: {
-            ...next.channels,
-            signal: {
-              ...next.channels?.signal,
-              enabled: true,
-              ...(input.signalNumber ? { account: input.signalNumber } : {}),
-              ...(input.cliPath ? { cliPath: input.cliPath } : {}),
-              ...(input.httpUrl ? { httpUrl: input.httpUrl } : {}),
-              ...(input.httpHost ? { httpHost: input.httpHost } : {}),
-              ...(input.httpPort ? { httpPort: Number(input.httpPort) } : {}),
-            },
-          },
-        };
-      }
-      return {
-        ...next,
-        channels: {
-          ...next.channels,
-          signal: {
-            ...next.channels?.signal,
-            enabled: true,
-            accounts: {
-              ...next.channels?.signal?.accounts,
-              [accountId]: {
-                ...next.channels?.signal?.accounts?.[accountId],
-                enabled: true,
-                ...(input.signalNumber ? { account: input.signalNumber } : {}),
-                ...(input.cliPath ? { cliPath: input.cliPath } : {}),
-                ...(input.httpUrl ? { httpUrl: input.httpUrl } : {}),
-                ...(input.httpHost ? { httpHost: input.httpHost } : {}),
-                ...(input.httpPort ? { httpPort: Number(input.httpPort) } : {}),
-              },
-            },
-          },
-        },
-      };
-    },
-  },
-  outbound: {
-    deliveryMode: "direct",
-    chunker: (text, limit) => getSignalRuntime().channel.text.chunkText(text, limit),
-    chunkerMode: "text",
-    textChunkLimit: 4000,
-    sendText: async ({ cfg, to, text, accountId, deps }) => {
-      const send = deps?.sendSignal ?? getSignalRuntime().channel.signal.sendMessageSignal;
-      const maxBytes = resolveChannelMediaMaxBytes({
-        cfg,
-        resolveChannelLimitMb: ({ cfg, accountId }) =>
-          cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ??
-          cfg.channels?.signal?.mediaMaxMb,
-        accountId,
-      });
-      const result = await send(to, text, {
-        maxBytes,
-        accountId: accountId ?? undefined,
-      });
-      return { channel: "signal", ...result };
-    },
-    sendMedia: async ({ cfg, to, text, mediaUrl, accountId, deps }) => {
-      const send = deps?.sendSignal ?? getSignalRuntime().channel.signal.sendMessageSignal;
-      const maxBytes = resolveChannelMediaMaxBytes({
-        cfg,
-        resolveChannelLimitMb: ({ cfg, accountId }) =>
-          cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ??
-          cfg.channels?.signal?.mediaMaxMb,
-        accountId,
-      });
-      const result = await send(to, text, {
-        mediaUrl,
-        maxBytes,
-        accountId: accountId ?? undefined,
-      });
-      return { channel: "signal", ...result };
-    },
-  },
-  status: {
-    defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
-    collectStatusIssues: (accounts) => collectStatusIssuesFromLastError("signal", accounts),
-    buildChannelSummary: ({ snapshot }) => ({
-      ...buildBaseChannelStatusSummary(snapshot),
-      baseUrl: snapshot.baseUrl ?? null,
-      probe: snapshot.probe,
-      lastProbeAt: snapshot.lastProbeAt ?? null,
-    }),
-    probeAccount: async ({ account, timeoutMs }) => {
-      const baseUrl = account.baseUrl;
-      return await getSignalRuntime().channel.signal.probeSignal(baseUrl, timeoutMs);
-    },
-    buildAccountSnapshot: ({ account, runtime, probe }) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      baseUrl: account.baseUrl,
-      running: runtime?.running ?? false,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-      probe,
-      lastInboundAt: runtime?.lastInboundAt ?? null,
-      lastOutboundAt: runtime?.lastOutboundAt ?? null,
-    }),
-  },
-  gateway: {
-    startAccount: async (ctx) => {
-      const account = ctx.account;
-      ctx.setStatus({
-        accountId: account.accountId,
-        baseUrl: account.baseUrl,
-      });
-      ctx.log?.info(`[${account.accountId}] starting provider (${account.baseUrl})`);
-      // Lazy import: the monitor pulls the reply pipeline; avoid ESM init cycles.
-      return getSignalRuntime().channel.signal.monitorSignalProvider({
-        accountId: account.accountId,
-        config: ctx.cfg,
-        runtime: ctx.runtime,
-        abortSignal: ctx.abortSignal,
-        mediaMaxMb: account.config.mediaMaxMb,
-      });
-    },
-  },
-};

package/extensions/signal/src/runtime.ts

@@ -1,14 +0,0 @@
-import type { PluginRuntime } from "symi/plugin-sdk";
-
-let runtime: PluginRuntime | null = null;
-
-export function setSignalRuntime(next: PluginRuntime) {
-  runtime = next;
-}
-
-export function getSignalRuntime(): PluginRuntime {
-  if (!runtime) {
-    throw new Error("Signal runtime not initialized");
-  }
-  return runtime;
-}

package/extensions/signal/symi.plugin.json

@@ -1,9 +0,0 @@
-{
-  "id": "signal",
-  "channels": ["signal"],
-  "configSchema": {
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {}
-  }
-}

package/extensions/telegram/index.ts

@@ -1,17 +0,0 @@
-import type { ChannelPlugin, SymiPluginApi } from "symi/plugin-sdk";
-import { emptyPluginConfigSchema } from "symi/plugin-sdk";
-import { telegramPlugin } from "./src/channel.js";
-import { setTelegramRuntime } from "./src/runtime.js";
-
-const plugin = {
-  id: "telegram",
-  name: "Telegram",
-  description: "Telegram channel plugin",
-  configSchema: emptyPluginConfigSchema(),
-  register(api: SymiPluginApi) {
-    setTelegramRuntime(api.runtime);
-    api.registerChannel({ plugin: telegramPlugin as ChannelPlugin });
-  },
-};
-
-export default plugin;

package/extensions/telegram/node_modules/.bin/symi

@@ -1,21 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*)
-        if command -v cygpath > /dev/null 2>&1; then
-            basedir=`cygpath -w "$basedir"`
-        fi
-    ;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/home/symi/projects/symi/node_modules:/home/symi/projects/node_modules:/home/symi/node_modules:/home/node_modules:/node_modules:/home/symi/projects/symi/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/home/symi/projects/symi/node_modules:/home/symi/projects/node_modules:/home/symi/node_modules:/home/node_modules:/node_modules:/home/symi/projects/symi/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../@symerian/symi/symi.mjs" "$@"
-else
-  exec node  "$basedir/../@symerian/symi/symi.mjs" "$@"
-fi

package/extensions/telegram/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "@symi/telegram",
-  "version": "3.0.9",
-  "private": true,
-  "description": "Symi Telegram channel plugin",
-  "type": "module",
-  "devDependencies": {
-    "@symerian/symi": "workspace:*"
-  },
-  "symi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  }
-}

package/extensions/telegram/src/channel.test.ts

@@ -1,125 +0,0 @@
-import type {
-  ChannelAccountSnapshot,
-  ChannelGatewayContext,
-  SymiConfig,
-  PluginRuntime,
-  ResolvedTelegramAccount,
-  RuntimeEnv,
-} from "symi/plugin-sdk";
-import { describe, expect, it, vi } from "vitest";
-import { telegramPlugin } from "./channel.js";
-import { setTelegramRuntime } from "./runtime.js";
-
-function createCfg(): SymiConfig {
-  return {
-    channels: {
-      telegram: {
-        enabled: true,
-        accounts: {
-          alerts: { botToken: "token-shared" },
-          work: { botToken: "token-shared" },
-          ops: { botToken: "token-ops" },
-        },
-      },
-    },
-  } as SymiConfig;
-}
-
-function createRuntimeEnv(): RuntimeEnv {
-  return {
-    log: vi.fn(),
-    error: vi.fn(),
-    exit: vi.fn((code: number): never => {
-      throw new Error(`exit ${code}`);
-    }),
-  };
-}
-
-function createStartAccountCtx(params: {
-  cfg: SymiConfig;
-  accountId: string;
-  runtime: RuntimeEnv;
-}): ChannelGatewayContext<ResolvedTelegramAccount> {
-  const account = telegramPlugin.config.resolveAccount(
-    params.cfg,
-    params.accountId,
-  ) as ResolvedTelegramAccount;
-  const snapshot: ChannelAccountSnapshot = {
-    accountId: params.accountId,
-    configured: true,
-    enabled: true,
-    running: false,
-  };
-  return {
-    accountId: params.accountId,
-    account,
-    cfg: params.cfg,
-    runtime: params.runtime,
-    abortSignal: new AbortController().signal,
-    log: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-    getStatus: () => snapshot,
-    setStatus: vi.fn(),
-  };
-}
-
-describe("telegramPlugin duplicate token guard", () => {
-  it("marks secondary account as not configured when token is shared", async () => {
-    const cfg = createCfg();
-    const alertsAccount = telegramPlugin.config.resolveAccount(cfg, "alerts");
-    const workAccount = telegramPlugin.config.resolveAccount(cfg, "work");
-    const opsAccount = telegramPlugin.config.resolveAccount(cfg, "ops");
-
-    expect(await telegramPlugin.config.isConfigured!(alertsAccount, cfg)).toBe(true);
-    expect(await telegramPlugin.config.isConfigured!(workAccount, cfg)).toBe(false);
-    expect(await telegramPlugin.config.isConfigured!(opsAccount, cfg)).toBe(true);
-
-    expect(telegramPlugin.config.unconfiguredReason?.(workAccount, cfg)).toContain(
-      'account "alerts"',
-    );
-  });
-
-  it("surfaces duplicate-token reason in status snapshot", async () => {
-    const cfg = createCfg();
-    const workAccount = telegramPlugin.config.resolveAccount(cfg, "work");
-    const snapshot = await telegramPlugin.status!.buildAccountSnapshot!({
-      account: workAccount,
-      cfg,
-      runtime: undefined,
-      probe: undefined,
-      audit: undefined,
-    });
-
-    expect(snapshot.configured).toBe(false);
-    expect(snapshot.lastError).toContain('account "alerts"');
-  });
-
-  it("blocks startup for duplicate token accounts before polling starts", async () => {
-    const monitorTelegramProvider = vi.fn(async () => undefined);
-    const probeTelegram = vi.fn(async () => ({ ok: true, bot: { username: "bot" } }));
-    const runtime = {
-      channel: {
-        telegram: {
-          monitorTelegramProvider,
-          probeTelegram,
-        },
-      },
-      logging: {
-        shouldLogVerbose: () => false,
-      },
-    } as unknown as PluginRuntime;
-    setTelegramRuntime(runtime);
-
-    await expect(
-      telegramPlugin.gateway!.startAccount!(
-        createStartAccountCtx({
-          cfg: createCfg(),
-          accountId: "work",
-          runtime: createRuntimeEnv(),
-        }),
-      ),
-    ).rejects.toThrow("Duplicate Telegram bot token");
-
-    expect(probeTelegram).not.toHaveBeenCalled();
-    expect(monitorTelegramProvider).not.toHaveBeenCalled();
-  });
-});