@symerian/symi 3.0.18 → 3.0.19

package/extensions/qwen-portal-auth/index.ts

@@ -1,134 +0,0 @@
-import {
-  emptyPluginConfigSchema,
-  type SymiPluginApi,
-  type ProviderAuthContext,
-} from "symi/plugin-sdk";
-import { loginQwenPortalOAuth } from "./oauth.js";
-
-const PROVIDER_ID = "qwen-portal";
-const PROVIDER_LABEL = "Qwen";
-const DEFAULT_MODEL = "qwen-portal/coder-model";
-const DEFAULT_BASE_URL = "https://portal.qwen.ai/v1";
-const DEFAULT_CONTEXT_WINDOW = 128000;
-const DEFAULT_MAX_TOKENS = 8192;
-const OAUTH_PLACEHOLDER = "qwen-oauth";
-
-function normalizeBaseUrl(value: string | undefined): string {
-  const raw = value?.trim() || DEFAULT_BASE_URL;
-  const withProtocol = raw.startsWith("http") ? raw : `https://${raw}`;
-  return withProtocol.endsWith("/v1") ? withProtocol : `${withProtocol.replace(/\/+$/, "")}/v1`;
-}
-
-function buildModelDefinition(params: {
-  id: string;
-  name: string;
-  input: Array<"text" | "image">;
-}) {
-  return {
-    id: params.id,
-    name: params.name,
-    reasoning: false,
-    input: params.input,
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: DEFAULT_CONTEXT_WINDOW,
-    maxTokens: DEFAULT_MAX_TOKENS,
-  };
-}
-
-const qwenPortalPlugin = {
-  id: "qwen-portal-auth",
-  name: "Qwen OAuth",
-  description: "OAuth flow for Qwen (free-tier) models",
-  configSchema: emptyPluginConfigSchema(),
-  register(api: SymiPluginApi) {
-    api.registerProvider({
-      id: PROVIDER_ID,
-      label: PROVIDER_LABEL,
-      docsPath: "/providers/qwen",
-      aliases: ["qwen"],
-      auth: [
-        {
-          id: "device",
-          label: "Qwen OAuth",
-          hint: "Device code login",
-          kind: "device_code",
-          run: async (ctx: ProviderAuthContext) => {
-            const progress = ctx.prompter.progress("Starting Qwen OAuth…");
-            try {
-              const result = await loginQwenPortalOAuth({
-                openUrl: ctx.openUrl,
-                note: ctx.prompter.note,
-                progress,
-              });
-
-              progress.stop("Qwen OAuth complete");
-
-              const profileId = `${PROVIDER_ID}:default`;
-              const baseUrl = normalizeBaseUrl(result.resourceUrl);
-
-              return {
-                profiles: [
-                  {
-                    profileId,
-                    credential: {
-                      type: "oauth",
-                      provider: PROVIDER_ID,
-                      access: result.access,
-                      refresh: result.refresh,
-                      expires: result.expires,
-                    },
-                  },
-                ],
-                configPatch: {
-                  models: {
-                    providers: {
-                      [PROVIDER_ID]: {
-                        baseUrl,
-                        apiKey: OAUTH_PLACEHOLDER,
-                        api: "openai-completions",
-                        models: [
-                          buildModelDefinition({
-                            id: "coder-model",
-                            name: "Qwen Coder",
-                            input: ["text"],
-                          }),
-                          buildModelDefinition({
-                            id: "vision-model",
-                            name: "Qwen Vision",
-                            input: ["text", "image"],
-                          }),
-                        ],
-                      },
-                    },
-                  },
-                  agents: {
-                    defaults: {
-                      models: {
-                        "qwen-portal/coder-model": { alias: "qwen" },
-                        "qwen-portal/vision-model": {},
-                      },
-                    },
-                  },
-                },
-                defaultModel: DEFAULT_MODEL,
-                notes: [
-                  "Qwen OAuth tokens auto-refresh. Re-run login if refresh fails or access is revoked.",
-                  `Base URL defaults to ${DEFAULT_BASE_URL}. Override models.providers.${PROVIDER_ID}.baseUrl if needed.`,
-                ],
-              };
-            } catch (err) {
-              progress.stop("Qwen OAuth failed");
-              await ctx.prompter.note(
-                "If OAuth fails, verify your Qwen account has portal access and try again.",
-                "Qwen OAuth",
-              );
-              throw err;
-            }
-          },
-        },
-      ],
-    });
-  },
-};
-
-export default qwenPortalPlugin;

package/extensions/qwen-portal-auth/oauth.ts

@@ -1,190 +0,0 @@
-import { createHash, randomBytes, randomUUID } from "node:crypto";
-
-const QWEN_OAUTH_BASE_URL = "https://chat.qwen.ai";
-const QWEN_OAUTH_DEVICE_CODE_ENDPOINT = `${QWEN_OAUTH_BASE_URL}/api/v1/oauth2/device/code`;
-const QWEN_OAUTH_TOKEN_ENDPOINT = `${QWEN_OAUTH_BASE_URL}/api/v1/oauth2/token`;
-const QWEN_OAUTH_CLIENT_ID = "f0304373b74a44d2b584a3fb70ca9e56";
-const QWEN_OAUTH_SCOPE = "openid profile email model.completion";
-const QWEN_OAUTH_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
-
-export type QwenDeviceAuthorization = {
-  device_code: string;
-  user_code: string;
-  verification_uri: string;
-  verification_uri_complete?: string;
-  expires_in: number;
-  interval?: number;
-};
-
-export type QwenOAuthToken = {
-  access: string;
-  refresh: string;
-  expires: number;
-  resourceUrl?: string;
-};
-
-type TokenPending = { status: "pending"; slowDown?: boolean };
-
-type DeviceTokenResult =
-  | { status: "success"; token: QwenOAuthToken }
-  | TokenPending
-  | { status: "error"; message: string };
-
-function toFormUrlEncoded(data: Record<string, string>): string {
-  return Object.entries(data)
-    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-    .join("&");
-}
-
-function generatePkce(): { verifier: string; challenge: string } {
-  const verifier = randomBytes(32).toString("base64url");
-  const challenge = createHash("sha256").update(verifier).digest("base64url");
-  return { verifier, challenge };
-}
-
-async function requestDeviceCode(params: { challenge: string }): Promise<QwenDeviceAuthorization> {
-  const response = await fetch(QWEN_OAUTH_DEVICE_CODE_ENDPOINT, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-      Accept: "application/json",
-      "x-request-id": randomUUID(),
-    },
-    body: toFormUrlEncoded({
-      client_id: QWEN_OAUTH_CLIENT_ID,
-      scope: QWEN_OAUTH_SCOPE,
-      code_challenge: params.challenge,
-      code_challenge_method: "S256",
-    }),
-  });
-
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`Qwen device authorization failed: ${text || response.statusText}`);
-  }
-
-  const payload = (await response.json()) as QwenDeviceAuthorization & { error?: string };
-  if (!payload.device_code || !payload.user_code || !payload.verification_uri) {
-    throw new Error(
-      payload.error ??
-        "Qwen device authorization returned an incomplete payload (missing user_code or verification_uri).",
-    );
-  }
-  return payload;
-}
-
-async function pollDeviceToken(params: {
-  deviceCode: string;
-  verifier: string;
-}): Promise<DeviceTokenResult> {
-  const response = await fetch(QWEN_OAUTH_TOKEN_ENDPOINT, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-      Accept: "application/json",
-    },
-    body: toFormUrlEncoded({
-      grant_type: QWEN_OAUTH_GRANT_TYPE,
-      client_id: QWEN_OAUTH_CLIENT_ID,
-      device_code: params.deviceCode,
-      code_verifier: params.verifier,
-    }),
-  });
-
-  if (!response.ok) {
-    let payload: { error?: string; error_description?: string } | undefined;
-    try {
-      payload = (await response.json()) as { error?: string; error_description?: string };
-    } catch {
-      const text = await response.text();
-      return { status: "error", message: text || response.statusText };
-    }
-
-    if (payload?.error === "authorization_pending") {
-      return { status: "pending" };
-    }
-
-    if (payload?.error === "slow_down") {
-      return { status: "pending", slowDown: true };
-    }
-
-    return {
-      status: "error",
-      message: payload?.error_description || payload?.error || response.statusText,
-    };
-  }
-
-  const tokenPayload = (await response.json()) as {
-    access_token?: string | null;
-    refresh_token?: string | null;
-    expires_in?: number | null;
-    token_type?: string;
-    resource_url?: string;
-  };
-
-  if (!tokenPayload.access_token || !tokenPayload.refresh_token || !tokenPayload.expires_in) {
-    return { status: "error", message: "Qwen OAuth returned incomplete token payload." };
-  }
-
-  return {
-    status: "success",
-    token: {
-      access: tokenPayload.access_token,
-      refresh: tokenPayload.refresh_token,
-      expires: Date.now() + tokenPayload.expires_in * 1000,
-      resourceUrl: tokenPayload.resource_url,
-    },
-  };
-}
-
-export async function loginQwenPortalOAuth(params: {
-  openUrl: (url: string) => Promise<void>;
-  note: (message: string, title?: string) => Promise<void>;
-  progress: { update: (message: string) => void; stop: (message?: string) => void };
-}): Promise<QwenOAuthToken> {
-  const { verifier, challenge } = generatePkce();
-  const device = await requestDeviceCode({ challenge });
-  const verificationUrl = device.verification_uri_complete || device.verification_uri;
-
-  await params.note(
-    [
-      `Open ${verificationUrl} to approve access.`,
-      `If prompted, enter the code ${device.user_code}.`,
-    ].join("\n"),
-    "Qwen OAuth",
-  );
-
-  try {
-    await params.openUrl(verificationUrl);
-  } catch {
-    // Fall back to manual copy/paste if browser open fails.
-  }
-
-  const start = Date.now();
-  let pollIntervalMs = device.interval ? device.interval * 1000 : 2000;
-  const timeoutMs = device.expires_in * 1000;
-
-  while (Date.now() - start < timeoutMs) {
-    params.progress.update("Waiting for Qwen OAuth approval…");
-    const result = await pollDeviceToken({
-      deviceCode: device.device_code,
-      verifier,
-    });
-
-    if (result.status === "success") {
-      return result.token;
-    }
-
-    if (result.status === "error") {
-      throw new Error(`Qwen OAuth failed: ${result.message}`);
-    }
-
-    if (result.status === "pending" && result.slowDown) {
-      pollIntervalMs = Math.min(pollIntervalMs * 1.5, 10000);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-  }
-
-  throw new Error("Qwen OAuth timed out waiting for authorization.");
-}

package/extensions/qwen-portal-auth/symi.plugin.json

@@ -1,9 +0,0 @@
-{
-  "id": "qwen-portal-auth",
-  "providers": ["qwen-portal"],
-  "configSchema": {
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {}
-  }
-}

package/extensions/talk-voice/index.ts

@@ -1,150 +0,0 @@
-import type { SymiPluginApi } from "symi/plugin-sdk";
-
-type ElevenLabsVoice = {
-  voice_id: string;
-  name?: string;
-  category?: string;
-  description?: string;
-};
-
-function mask(s: string, keep: number = 6): string {
-  const trimmed = s.trim();
-  if (trimmed.length <= keep) {
-    return "***";
-  }
-  return `${trimmed.slice(0, keep)}…`;
-}
-
-function isLikelyVoiceId(value: string): boolean {
-  const v = value.trim();
-  if (v.length < 10 || v.length > 64) {
-    return false;
-  }
-  return /^[a-zA-Z0-9_-]+$/.test(v);
-}
-
-async function listVoices(apiKey: string): Promise<ElevenLabsVoice[]> {
-  const res = await fetch("https://api.elevenlabs.io/v1/voices", {
-    headers: {
-      "xi-api-key": apiKey,
-    },
-  });
-  if (!res.ok) {
-    throw new Error(`ElevenLabs voices API error (${res.status})`);
-  }
-  const json = (await res.json()) as { voices?: ElevenLabsVoice[] };
-  return Array.isArray(json.voices) ? json.voices : [];
-}
-
-function formatVoiceList(voices: ElevenLabsVoice[], limit: number): string {
-  const sliced = voices.slice(0, Math.max(1, Math.min(limit, 50)));
-  const lines: string[] = [];
-  lines.push(`Voices: ${voices.length}`);
-  lines.push("");
-  for (const v of sliced) {
-    const name = (v.name ?? "").trim() || "(unnamed)";
-    const category = (v.category ?? "").trim();
-    const meta = category ? ` · ${category}` : "";
-    lines.push(`- ${name}${meta}`);
-    lines.push(`  id: ${v.voice_id}`);
-  }
-  if (voices.length > sliced.length) {
-    lines.push("");
-    lines.push(`(showing first ${sliced.length})`);
-  }
-  return lines.join("\n");
-}
-
-function findVoice(voices: ElevenLabsVoice[], query: string): ElevenLabsVoice | null {
-  const q = query.trim();
-  if (!q) {
-    return null;
-  }
-  const lower = q.toLowerCase();
-  const byId = voices.find((v) => v.voice_id === q);
-  if (byId) {
-    return byId;
-  }
-  const exactName = voices.find((v) => (v.name ?? "").trim().toLowerCase() === lower);
-  if (exactName) {
-    return exactName;
-  }
-  const partial = voices.find((v) => (v.name ?? "").trim().toLowerCase().includes(lower));
-  return partial ?? null;
-}
-
-export default function register(api: SymiPluginApi) {
-  api.registerCommand({
-    name: "voice",
-    description: "List/set ElevenLabs Talk voice (affects iOS Talk playback).",
-    acceptsArgs: true,
-    handler: async (ctx) => {
-      const args = ctx.args?.trim() ?? "";
-      const tokens = args.split(/\s+/).filter(Boolean);
-      const action = (tokens[0] ?? "status").toLowerCase();
-
-      const cfg = api.runtime.config.loadConfig();
-      const apiKey = (cfg.talk?.apiKey ?? "").trim();
-      if (!apiKey) {
-        return {
-          text:
-            "Talk voice is not configured.\n\n" +
-            "Missing: talk.apiKey (ElevenLabs API key).\n" +
-            "Set it on the gateway, then retry.",
-        };
-      }
-
-      const currentVoiceId = (cfg.talk?.voiceId ?? "").trim();
-
-      if (action === "status") {
-        return {
-          text:
-            "Talk voice status:\n" +
-            `- talk.voiceId: ${currentVoiceId ? currentVoiceId : "(unset)"}\n` +
-            `- talk.apiKey: ${mask(apiKey)}`,
-        };
-      }
-
-      if (action === "list") {
-        const limit = Number.parseInt(tokens[1] ?? "12", 10);
-        const voices = await listVoices(apiKey);
-        return { text: formatVoiceList(voices, Number.isFinite(limit) ? limit : 12) };
-      }
-
-      if (action === "set") {
-        const query = tokens.slice(1).join(" ").trim();
-        if (!query) {
-          return { text: "Usage: /voice set <voiceId|name>" };
-        }
-        const voices = await listVoices(apiKey);
-        const chosen = findVoice(voices, query);
-        if (!chosen) {
-          const hint = isLikelyVoiceId(query) ? query : `"${query}"`;
-          return { text: `No voice found for ${hint}. Try: /voice list` };
-        }
-
-        const nextConfig = {
-          ...cfg,
-          talk: {
-            ...cfg.talk,
-            voiceId: chosen.voice_id,
-          },
-        };
-        await api.runtime.config.writeConfigFile(nextConfig);
-
-        const name = (chosen.name ?? "").trim() || "(unnamed)";
-        return { text: `✅ Talk voice set to ${name}\n${chosen.voice_id}` };
-      }
-
-      return {
-        text: [
-          "Voice commands:",
-          "",
-          "/voice status",
-          "/voice list [limit]",
-          "/voice set <voiceId|name>",
-        ].join("\n"),
-      };
-    },
-  });
-}

package/extensions/talk-voice/symi.plugin.json

@@ -1,10 +0,0 @@
-{
-  "id": "talk-voice",
-  "name": "Talk Voice",
-  "description": "Manage Talk voice selection (list/set).",
-  "configSchema": {
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {}
-  }
-}

package/extensions/thread-ownership/index.test.ts

@@ -1,180 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import register from "./index.js";
-
-describe("thread-ownership plugin", () => {
-  const hooks: Record<string, Function> = {};
-  const api = {
-    pluginConfig: {},
-    config: {
-      agents: {
-        list: [{ id: "test-agent", default: true, identity: { name: "TestBot" } }],
-      },
-    },
-    id: "thread-ownership",
-    name: "Thread Ownership",
-    logger: { info: vi.fn(), warn: vi.fn(), debug: vi.fn() },
-    on: vi.fn((hookName: string, handler: Function) => {
-      hooks[hookName] = handler;
-    }),
-  };
-
-  let originalFetch: typeof globalThis.fetch;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    for (const key of Object.keys(hooks)) delete hooks[key];
-
-    process.env.SLACK_FORWARDER_URL = "http://localhost:8750";
-    process.env.SLACK_BOT_USER_ID = "U999";
-
-    originalFetch = globalThis.fetch;
-    globalThis.fetch = vi.fn() as unknown as typeof globalThis.fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-    delete process.env.SLACK_FORWARDER_URL;
-    delete process.env.SLACK_BOT_USER_ID;
-    vi.restoreAllMocks();
-  });
-
-  it("registers message_received and message_sending hooks", () => {
-    register(api as any);
-
-    expect(api.on).toHaveBeenCalledTimes(2);
-    expect(api.on).toHaveBeenCalledWith("message_received", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("message_sending", expect.any(Function));
-  });
-
-  describe("message_sending", () => {
-    beforeEach(() => {
-      register(api as any);
-    });
-
-    it("allows non-slack channels", async () => {
-      const result = await hooks.message_sending(
-        { content: "hello", metadata: { threadTs: "1234.5678", channelId: "C123" }, to: "C123" },
-        { channelId: "telegram", conversationId: "C123" },
-      );
-
-      expect(result).toBeUndefined();
-      expect(globalThis.fetch).not.toHaveBeenCalled();
-    });
-
-    it("allows top-level messages (no threadTs)", async () => {
-      const result = await hooks.message_sending(
-        { content: "hello", metadata: {}, to: "C123" },
-        { channelId: "slack", conversationId: "C123" },
-      );
-
-      expect(result).toBeUndefined();
-      expect(globalThis.fetch).not.toHaveBeenCalled();
-    });
-
-    it("claims ownership successfully", async () => {
-      vi.mocked(globalThis.fetch).mockResolvedValue(
-        new Response(JSON.stringify({ owner: "test-agent" }), { status: 200 }),
-      );
-
-      const result = await hooks.message_sending(
-        { content: "hello", metadata: { threadTs: "1234.5678", channelId: "C123" }, to: "C123" },
-        { channelId: "slack", conversationId: "C123" },
-      );
-
-      expect(result).toBeUndefined();
-      expect(globalThis.fetch).toHaveBeenCalledWith(
-        "http://localhost:8750/api/v1/ownership/C123/1234.5678",
-        expect.objectContaining({
-          method: "POST",
-          body: JSON.stringify({ agent_id: "test-agent" }),
-        }),
-      );
-    });
-
-    it("cancels when thread owned by another agent", async () => {
-      vi.mocked(globalThis.fetch).mockResolvedValue(
-        new Response(JSON.stringify({ owner: "other-agent" }), { status: 409 }),
-      );
-
-      const result = await hooks.message_sending(
-        { content: "hello", metadata: { threadTs: "1234.5678", channelId: "C123" }, to: "C123" },
-        { channelId: "slack", conversationId: "C123" },
-      );
-
-      expect(result).toEqual({ cancel: true });
-      expect(api.logger.info).toHaveBeenCalledWith(expect.stringContaining("cancelled send"));
-    });
-
-    it("fails open on network error", async () => {
-      vi.mocked(globalThis.fetch).mockRejectedValue(new Error("ECONNREFUSED"));
-
-      const result = await hooks.message_sending(
-        { content: "hello", metadata: { threadTs: "1234.5678", channelId: "C123" }, to: "C123" },
-        { channelId: "slack", conversationId: "C123" },
-      );
-
-      expect(result).toBeUndefined();
-      expect(api.logger.warn).toHaveBeenCalledWith(
-        expect.stringContaining("ownership check failed"),
-      );
-    });
-  });
-
-  describe("message_received @-mention tracking", () => {
-    beforeEach(() => {
-      register(api as any);
-    });
-
-    it("tracks @-mentions and skips ownership check for mentioned threads", async () => {
-      // Simulate receiving a message that @-mentions the agent.
-      await hooks.message_received(
-        { content: "Hey @TestBot help me", metadata: { threadTs: "9999.0001", channelId: "C456" } },
-        { channelId: "slack", conversationId: "C456" },
-      );
-
-      // Now send in the same thread -- should skip the ownership HTTP call.
-      const result = await hooks.message_sending(
-        { content: "Sure!", metadata: { threadTs: "9999.0001", channelId: "C456" }, to: "C456" },
-        { channelId: "slack", conversationId: "C456" },
-      );
-
-      expect(result).toBeUndefined();
-      expect(globalThis.fetch).not.toHaveBeenCalled();
-    });
-
-    it("ignores @-mentions on non-slack channels", async () => {
-      // Use a unique thread key so module-level state from other tests doesn't interfere.
-      await hooks.message_received(
-        { content: "Hey @TestBot", metadata: { threadTs: "7777.0001", channelId: "C999" } },
-        { channelId: "telegram", conversationId: "C999" },
-      );
-
-      // The mention should not have been tracked, so sending should still call fetch.
-      vi.mocked(globalThis.fetch).mockResolvedValue(
-        new Response(JSON.stringify({ owner: "test-agent" }), { status: 200 }),
-      );
-
-      await hooks.message_sending(
-        { content: "Sure!", metadata: { threadTs: "7777.0001", channelId: "C999" }, to: "C999" },
-        { channelId: "slack", conversationId: "C999" },
-      );
-
-      expect(globalThis.fetch).toHaveBeenCalled();
-    });
-
-    it("tracks bot user ID mentions via <@U999> syntax", async () => {
-      await hooks.message_received(
-        { content: "Hey <@U999> help", metadata: { threadTs: "8888.0001", channelId: "C789" } },
-        { channelId: "slack", conversationId: "C789" },
-      );
-
-      const result = await hooks.message_sending(
-        { content: "On it!", metadata: { threadTs: "8888.0001", channelId: "C789" }, to: "C789" },
-        { channelId: "slack", conversationId: "C789" },
-      );
-
-      expect(result).toBeUndefined();
-      expect(globalThis.fetch).not.toHaveBeenCalled();
-    });
-  });
-});