@symerian/symi 3.0.18 → 3.0.19

package/extensions/model-equalizer/src/test/integration.test.ts

@@ -1,185 +0,0 @@
-import type { SymiConfig } from "symi/plugin-sdk";
-import { describe, it, expect } from "vitest";
-import { buildProviderMap, isLocalProvider, resolveDefaultProvider } from "../detection.js";
-import { buildEnhancement } from "../enhancer.js";
-import { resolveConfig } from "../types.js";
-
-describe("Model Equalizer Integration", () => {
-  // Simulate the full flow that index.ts performs
-
-  function simulateEnhancement(
-    config: SymiConfig,
-    pluginConfig: Record<string, unknown> | undefined,
-    prompt: string,
-    cachedProvider?: string,
-  ): string | null {
-    const cfg = resolveConfig(pluginConfig);
-    if (!cfg.enabled) return null;
-
-    const providerMap = buildProviderMap(config);
-    const provider = cachedProvider ?? resolveDefaultProvider(config);
-    if (!provider) return null;
-
-    const isLocal = providerMap.get(provider.trim().toLowerCase()) ?? isLocalProvider(provider);
-    if (!isLocal) return null;
-
-    return buildEnhancement(prompt, {
-      intensity: cfg.intensity,
-      minPromptLength: cfg.minPromptLength,
-    });
-  }
-
-  it("should enhance prompts when default agent uses ollama", () => {
-    const config: SymiConfig = {
-      models: {
-        providers: {
-          ollama: { baseUrl: "http://localhost:11434", models: [] },
-        },
-      },
-      agents: {
-        list: [{ id: "main", default: true, model: "ollama/llama3.1" }],
-      },
-    };
-    const result = simulateEnhancement(config, undefined, "Explain how async/await works in JS");
-    expect(result).not.toBeNull();
-    expect(result).toContain("<model-equalizer>");
-  });
-
-  it("should not enhance prompts when default agent uses openai", () => {
-    const config: SymiConfig = {
-      models: {
-        providers: {
-          openai: { baseUrl: "https://api.openai.com/v1", models: [] },
-        },
-      },
-      agents: {
-        list: [{ id: "main", default: true, model: "openai/gpt-4o" }],
-      },
-    };
-    const result = simulateEnhancement(config, undefined, "Explain how async/await works in JS");
-    expect(result).toBeNull();
-  });
-
-  it("should enhance when cached provider is local", () => {
-    const config: SymiConfig = {
-      models: {
-        providers: {
-          openai: { baseUrl: "https://api.openai.com/v1", models: [] },
-          ollama: { baseUrl: "http://localhost:11434", models: [] },
-        },
-      },
-      agents: {
-        list: [{ id: "main", default: true, model: "openai/gpt-4o" }],
-      },
-    };
-    // Default agent is openai, but cached provider is ollama
-    const result = simulateEnhancement(
-      config,
-      undefined,
-      "Explain how async/await works in JS",
-      "ollama",
-    );
-    expect(result).not.toBeNull();
-  });
-
-  it("should not enhance when cached provider is remote", () => {
-    const config: SymiConfig = {
-      models: {
-        providers: {
-          ollama: { baseUrl: "http://localhost:11434", models: [] },
-          openai: { baseUrl: "https://api.openai.com/v1", models: [] },
-        },
-      },
-      agents: {
-        list: [{ id: "main", default: true, model: "ollama/llama3" }],
-      },
-    };
-    // Default agent is ollama, but cached provider override is openai
-    const result = simulateEnhancement(
-      config,
-      undefined,
-      "Explain how async/await works in JS",
-      "openai",
-    );
-    expect(result).toBeNull();
-  });
-
-  it("should respect enabled=false in plugin config", () => {
-    const config: SymiConfig = {
-      agents: {
-        list: [{ id: "main", default: true, model: "ollama/llama3.1" }],
-      },
-    };
-    const result = simulateEnhancement(config, { enabled: false }, "Explain something");
-    expect(result).toBeNull();
-  });
-
-  it("should detect local provider by baseUrl even with unknown name", () => {
-    const config: SymiConfig = {
-      models: {
-        providers: {
-          "my-server": { baseUrl: "http://127.0.0.1:5000/v1", models: [] },
-        },
-      },
-      agents: {
-        list: [{ id: "main", default: true, model: "my-server/custom-model" }],
-      },
-    };
-    const result = simulateEnhancement(config, undefined, "Explain something in detail");
-    expect(result).not.toBeNull();
-  });
-
-  it("should skip very short prompts even for local providers", () => {
-    const config: SymiConfig = {
-      agents: {
-        list: [{ id: "main", default: true, model: "ollama/llama3" }],
-      },
-    };
-    const result = simulateEnhancement(config, undefined, "hi");
-    expect(result).toBeNull();
-  });
-
-  it("should use aggressive intensity when configured", () => {
-    const config: SymiConfig = {
-      agents: {
-        list: [{ id: "main", default: true, model: "ollama/llama3" }],
-      },
-    };
-    const result = simulateEnhancement(config, { intensity: "aggressive" }, "Simple question?");
-    expect(result).not.toBeNull();
-    expect(result).toContain("Decompose");
-  });
-
-  it("should return null when no agents are configured", () => {
-    const config: SymiConfig = {};
-    const result = simulateEnhancement(config, undefined, "Explain something");
-    expect(result).toBeNull();
-  });
-});
-
-describe("resolveConfig", () => {
-  it("should apply defaults for missing values", () => {
-    const cfg = resolveConfig(undefined);
-    expect(cfg.enabled).toBe(true);
-    expect(cfg.intensity).toBe("standard");
-    expect(cfg.minPromptLength).toBe(10);
-  });
-
-  it("should preserve explicit values", () => {
-    const cfg = resolveConfig({
-      enabled: false,
-      intensity: "aggressive",
-      minPromptLength: 50,
-    });
-    expect(cfg.enabled).toBe(false);
-    expect(cfg.intensity).toBe("aggressive");
-    expect(cfg.minPromptLength).toBe(50);
-  });
-
-  it("should handle partial config", () => {
-    const cfg = resolveConfig({ intensity: "light" });
-    expect(cfg.enabled).toBe(true);
-    expect(cfg.intensity).toBe("light");
-    expect(cfg.minPromptLength).toBe(10);
-  });
-});

package/extensions/model-equalizer/src/types.ts

@@ -1,24 +0,0 @@
-export type ModelEqualizerConfig = {
-  /** Whether the equalizer is active. Default: true. */
-  enabled?: boolean;
-  /** Enhancement intensity. Default: "standard". */
-  intensity?: "light" | "standard" | "aggressive";
-  /** Skip enhancement for prompts shorter than this. Default: 10. */
-  minPromptLength?: number;
-};
-
-export type DetectionState = {
-  /** Cached provider per session key. */
-  sessionProviders: Map<string, string>;
-  /** Pre-built provider→isLocal map from config. */
-  providerMap: Map<string, boolean>;
-};
-
-export function resolveConfig(raw: Record<string, unknown> | undefined): ModelEqualizerConfig {
-  const cfg = (raw ?? {}) as Partial<ModelEqualizerConfig>;
-  return {
-    enabled: cfg.enabled ?? true,
-    intensity: cfg.intensity ?? "standard",
-    minPromptLength: cfg.minPromptLength ?? 10,
-  };
-}

package/extensions/model-equalizer/symi.plugin.json

@@ -1,12 +0,0 @@
-{
-  "id": "model-equalizer",
-  "configSchema": {
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {
-      "enabled": { "type": "boolean" },
-      "intensity": { "enum": ["light", "standard", "aggressive"] },
-      "minPromptLength": { "type": "number" }
-    }
-  }
-}

package/extensions/phone-control/index.ts

@@ -1,421 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import type { SymiPluginApi, SymiPluginService } from "symi/plugin-sdk";
-
-type ArmGroup = "camera" | "screen" | "writes" | "all";
-
-type ArmStateFileV1 = {
-  version: 1;
-  armedAtMs: number;
-  expiresAtMs: number | null;
-  removedFromDeny: string[];
-};
-
-type ArmStateFileV2 = {
-  version: 2;
-  armedAtMs: number;
-  expiresAtMs: number | null;
-  group: ArmGroup;
-  armedCommands: string[];
-  addedToAllow: string[];
-  removedFromDeny: string[];
-};
-
-type ArmStateFile = ArmStateFileV1 | ArmStateFileV2;
-
-const STATE_VERSION = 2;
-const STATE_REL_PATH = ["plugins", "phone-control", "armed.json"] as const;
-
-const GROUP_COMMANDS: Record<Exclude<ArmGroup, "all">, string[]> = {
-  camera: ["camera.snap", "camera.clip"],
-  screen: ["screen.record"],
-  writes: ["calendar.add", "contacts.add", "reminders.add"],
-};
-
-function uniqSorted(values: string[]): string[] {
-  return [...new Set(values.map((v) => v.trim()).filter(Boolean))].toSorted();
-}
-
-function resolveCommandsForGroup(group: ArmGroup): string[] {
-  if (group === "all") {
-    return uniqSorted(Object.values(GROUP_COMMANDS).flat());
-  }
-  return uniqSorted(GROUP_COMMANDS[group]);
-}
-
-function formatGroupList(): string {
-  return ["camera", "screen", "writes", "all"].join(", ");
-}
-
-function parseDurationMs(input: string | undefined): number | null {
-  if (!input) {
-    return null;
-  }
-  const raw = input.trim().toLowerCase();
-  if (!raw) {
-    return null;
-  }
-  const m = raw.match(/^(\d+)(s|m|h|d)$/);
-  if (!m) {
-    return null;
-  }
-  const n = Number.parseInt(m[1] ?? "", 10);
-  if (!Number.isFinite(n) || n <= 0) {
-    return null;
-  }
-  const unit = m[2];
-  const mult = unit === "s" ? 1000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
-  return n * mult;
-}
-
-function formatDuration(ms: number): string {
-  const s = Math.max(0, Math.floor(ms / 1000));
-  if (s < 60) {
-    return `${s}s`;
-  }
-  const m = Math.floor(s / 60);
-  if (m < 60) {
-    return `${m}m`;
-  }
-  const h = Math.floor(m / 60);
-  if (h < 48) {
-    return `${h}h`;
-  }
-  const d = Math.floor(h / 24);
-  return `${d}d`;
-}
-
-function resolveStatePath(stateDir: string): string {
-  return path.join(stateDir, ...STATE_REL_PATH);
-}
-
-async function readArmState(statePath: string): Promise<ArmStateFile | null> {
-  try {
-    const raw = await fs.readFile(statePath, "utf8");
-    // Type as unknown record first to allow property access during validation
-    const parsed = JSON.parse(raw) as Record<string, unknown>;
-    if (parsed.version !== 1 && parsed.version !== 2) {
-      return null;
-    }
-    if (typeof parsed.armedAtMs !== "number") {
-      return null;
-    }
-    if (!(parsed.expiresAtMs === null || typeof parsed.expiresAtMs === "number")) {
-      return null;
-    }
-
-    if (parsed.version === 1) {
-      if (
-        !Array.isArray(parsed.removedFromDeny) ||
-        !parsed.removedFromDeny.every((v: unknown) => typeof v === "string")
-      ) {
-        return null;
-      }
-      return parsed as unknown as ArmStateFile;
-    }
-
-    const group = typeof parsed.group === "string" ? parsed.group : "";
-    if (group !== "camera" && group !== "screen" && group !== "writes" && group !== "all") {
-      return null;
-    }
-    if (
-      !Array.isArray(parsed.armedCommands) ||
-      !parsed.armedCommands.every((v: unknown) => typeof v === "string")
-    ) {
-      return null;
-    }
-    if (
-      !Array.isArray(parsed.addedToAllow) ||
-      !parsed.addedToAllow.every((v: unknown) => typeof v === "string")
-    ) {
-      return null;
-    }
-    if (
-      !Array.isArray(parsed.removedFromDeny) ||
-      !parsed.removedFromDeny.every((v: unknown) => typeof v === "string")
-    ) {
-      return null;
-    }
-    return parsed as unknown as ArmStateFile;
-  } catch {
-    return null;
-  }
-}
-
-async function writeArmState(statePath: string, state: ArmStateFile | null): Promise<void> {
-  await fs.mkdir(path.dirname(statePath), { recursive: true });
-  if (!state) {
-    try {
-      await fs.unlink(statePath);
-    } catch {
-      // ignore
-    }
-    return;
-  }
-  await fs.writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
-}
-
-function normalizeDenyList(cfg: SymiPluginApi["config"]): string[] {
-  return uniqSorted([...(cfg.gateway?.nodes?.denyCommands ?? [])]);
-}
-
-function normalizeAllowList(cfg: SymiPluginApi["config"]): string[] {
-  return uniqSorted([...(cfg.gateway?.nodes?.allowCommands ?? [])]);
-}
-
-function patchConfigNodeLists(
-  cfg: SymiPluginApi["config"],
-  next: { allowCommands: string[]; denyCommands: string[] },
-): SymiPluginApi["config"] {
-  return {
-    ...cfg,
-    gateway: {
-      ...cfg.gateway,
-      nodes: {
-        ...cfg.gateway?.nodes,
-        allowCommands: next.allowCommands,
-        denyCommands: next.denyCommands,
-      },
-    },
-  };
-}
-
-async function disarmNow(params: {
-  api: SymiPluginApi;
-  stateDir: string;
-  statePath: string;
-  reason: string;
-}): Promise<{ changed: boolean; restored: string[]; removed: string[] }> {
-  const { api, stateDir, statePath, reason } = params;
-  const state = await readArmState(statePath);
-  if (!state) {
-    return { changed: false, restored: [], removed: [] };
-  }
-  const cfg = api.runtime.config.loadConfig();
-  const allow = new Set(normalizeAllowList(cfg));
-  const deny = new Set(normalizeDenyList(cfg));
-  const removed: string[] = [];
-  const restored: string[] = [];
-
-  if (state.version === 1) {
-    for (const cmd of state.removedFromDeny) {
-      if (!deny.has(cmd)) {
-        deny.add(cmd);
-        restored.push(cmd);
-      }
-    }
-  } else {
-    for (const cmd of state.addedToAllow) {
-      if (allow.delete(cmd)) {
-        removed.push(cmd);
-      }
-    }
-    for (const cmd of state.removedFromDeny) {
-      if (!deny.has(cmd)) {
-        deny.add(cmd);
-        restored.push(cmd);
-      }
-    }
-  }
-
-  if (removed.length > 0 || restored.length > 0) {
-    const next = patchConfigNodeLists(cfg, {
-      allowCommands: uniqSorted([...allow]),
-      denyCommands: uniqSorted([...deny]),
-    });
-    await api.runtime.config.writeConfigFile(next);
-  }
-  await writeArmState(statePath, null);
-  api.logger.info(`phone-control: disarmed (${reason}) stateDir=${stateDir}`);
-  return {
-    changed: removed.length > 0 || restored.length > 0,
-    removed: uniqSorted(removed),
-    restored: uniqSorted(restored),
-  };
-}
-
-function formatHelp(): string {
-  return [
-    "Phone control commands:",
-    "",
-    "/phone status",
-    "/phone arm <group> [duration]",
-    "/phone disarm",
-    "",
-    "Groups:",
-    `- ${formatGroupList()}`,
-    "",
-    "Duration format: 30s | 10m | 2h | 1d (default: 10m).",
-    "",
-    "Notes:",
-    "- This only toggles what the gateway is allowed to invoke on phone nodes.",
-    "- iOS will still ask for permissions (camera, photos, contacts, etc.) on first use.",
-  ].join("\n");
-}
-
-function parseGroup(raw: string | undefined): ArmGroup | null {
-  const value = (raw ?? "").trim().toLowerCase();
-  if (!value) {
-    return null;
-  }
-  if (value === "camera" || value === "screen" || value === "writes" || value === "all") {
-    return value;
-  }
-  return null;
-}
-
-function formatStatus(state: ArmStateFile | null): string {
-  if (!state) {
-    return "Phone control: disarmed.";
-  }
-  const until =
-    state.expiresAtMs == null
-      ? "manual disarm required"
-      : `expires in ${formatDuration(Math.max(0, state.expiresAtMs - Date.now()))}`;
-  const cmds = uniqSorted(
-    state.version === 1
-      ? state.removedFromDeny
-      : state.armedCommands.length > 0
-        ? state.armedCommands
-        : [...state.addedToAllow, ...state.removedFromDeny],
-  );
-  const cmdLabel = cmds.length > 0 ? cmds.join(", ") : "none";
-  return `Phone control: armed (${until}).\nTemporarily allowed: ${cmdLabel}`;
-}
-
-export default function register(api: SymiPluginApi) {
-  let expiryInterval: ReturnType<typeof setInterval> | null = null;
-
-  const timerService: SymiPluginService = {
-    id: "phone-control-expiry",
-    start: async (ctx) => {
-      const statePath = resolveStatePath(ctx.stateDir);
-      const tick = async () => {
-        const state = await readArmState(statePath);
-        if (!state || state.expiresAtMs == null) {
-          return;
-        }
-        if (Date.now() < state.expiresAtMs) {
-          return;
-        }
-        await disarmNow({
-          api,
-          stateDir: ctx.stateDir,
-          statePath,
-          reason: "expired",
-        });
-      };
-
-      // Best effort; don't crash the gateway if state is corrupt.
-      await tick().catch(() => {});
-
-      expiryInterval = setInterval(() => {
-        tick().catch(() => {});
-      }, 15_000);
-      expiryInterval.unref?.();
-
-      return;
-    },
-    stop: async () => {
-      if (expiryInterval) {
-        clearInterval(expiryInterval);
-        expiryInterval = null;
-      }
-      return;
-    },
-  };
-
-  api.registerService(timerService);
-
-  api.registerCommand({
-    name: "phone",
-    description: "Arm/disarm high-risk phone node commands (camera/screen/writes).",
-    acceptsArgs: true,
-    handler: async (ctx) => {
-      const args = ctx.args?.trim() ?? "";
-      const tokens = args.split(/\s+/).filter(Boolean);
-      const action = tokens[0]?.toLowerCase() ?? "";
-
-      const stateDir = api.runtime.state.resolveStateDir();
-      const statePath = resolveStatePath(stateDir);
-
-      if (!action || action === "help") {
-        const state = await readArmState(statePath);
-        return { text: `${formatStatus(state)}\n\n${formatHelp()}` };
-      }
-
-      if (action === "status") {
-        const state = await readArmState(statePath);
-        return { text: formatStatus(state) };
-      }
-
-      if (action === "disarm") {
-        const res = await disarmNow({
-          api,
-          stateDir,
-          statePath,
-          reason: "manual",
-        });
-        if (!res.changed) {
-          return { text: "Phone control: disarmed." };
-        }
-        const restoredLabel = res.restored.length > 0 ? res.restored.join(", ") : "none";
-        const removedLabel = res.removed.length > 0 ? res.removed.join(", ") : "none";
-        return {
-          text: `Phone control: disarmed.\nRemoved allowlist: ${removedLabel}\nRestored denylist: ${restoredLabel}`,
-        };
-      }
-
-      if (action === "arm") {
-        const group = parseGroup(tokens[1]);
-        if (!group) {
-          return { text: `Usage: /phone arm <group> [duration]\nGroups: ${formatGroupList()}` };
-        }
-        const durationMs = parseDurationMs(tokens[2]) ?? 10 * 60_000;
-        const expiresAtMs = Date.now() + durationMs;
-
-        const commands = resolveCommandsForGroup(group);
-        const cfg = api.runtime.config.loadConfig();
-        const allowSet = new Set(normalizeAllowList(cfg));
-        const denySet = new Set(normalizeDenyList(cfg));
-
-        const addedToAllow: string[] = [];
-        const removedFromDeny: string[] = [];
-        for (const cmd of commands) {
-          if (!allowSet.has(cmd)) {
-            allowSet.add(cmd);
-            addedToAllow.push(cmd);
-          }
-          if (denySet.delete(cmd)) {
-            removedFromDeny.push(cmd);
-          }
-        }
-        const next = patchConfigNodeLists(cfg, {
-          allowCommands: uniqSorted([...allowSet]),
-          denyCommands: uniqSorted([...denySet]),
-        });
-        await api.runtime.config.writeConfigFile(next);
-
-        await writeArmState(statePath, {
-          version: STATE_VERSION,
-          armedAtMs: Date.now(),
-          expiresAtMs,
-          group,
-          armedCommands: uniqSorted(commands),
-          addedToAllow: uniqSorted(addedToAllow),
-          removedFromDeny: uniqSorted(removedFromDeny),
-        });
-
-        const allowedLabel = uniqSorted(commands).join(", ");
-        return {
-          text:
-            `Phone control: armed for ${formatDuration(durationMs)}.\n` +
-            `Temporarily allowed: ${allowedLabel}\n` +
-            `To disarm early: /phone disarm`,
-        };
-      }
-
-      return { text: formatHelp() };
-    },
-  });
-}

package/extensions/phone-control/symi.plugin.json

@@ -1,10 +0,0 @@
-{
-  "id": "phone-control",
-  "name": "Phone Control",
-  "description": "Arm/disarm high-risk phone node commands (camera/screen/writes) with an optional auto-expiry.",
-  "configSchema": {
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {}
-  }
-}