create-windy 0.8.2 → 0.9.1

package/template/apps/agent-server/native/profile-composition.test.ts

@@ -0,0 +1,147 @@
+import { expect, test } from "bun:test";
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import {
+  bundlePatchPaths,
+  composeEntries,
+  loadOverlayPatches,
+} from "@deepseek-ai/dsh-app-boot";
+import { nativeProfile } from "./profile";
+import { defaultHostFixture } from "./host-test-fixture.js";
+
+const require = createRequire(import.meta.url);
+function officialLayers() {
+  return ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-web-app"].flatMap(
+    (name) => {
+      const path = require.resolve(`${name}/package.json`);
+      const manifest = JSON.parse(readFileSync(path, "utf8"));
+      return bundlePatchPaths(dirname(path), manifest.dsh.bundle).map((patch) =>
+        loadOverlayPatches("test", patch),
+      );
+    },
+  );
+}
+
+test("official profile composition replaces privileged services with managed adapters", () => {
+  const layers = officialLayers();
+  const appRoot = resolve(import.meta.dir, "..");
+  const entries = composeEntries([
+    ...layers,
+    nativeProfile(
+      {
+        appRoot,
+        gateUrl: "http://127.0.0.1:9999",
+        model: "fixture",
+        contextWindow: 32768,
+        maxOutputTokens: 4096,
+        userExtensions: true,
+      },
+      defaultHostFixture,
+    ),
+  ]);
+  for (const id of ["settings-controller", "subprocess"]) {
+    expect(entries.find((entry) => entry.id === id)?.disabled).toBe(true);
+    const replacement = entries.find((entry) => entry.id === `windy-${id}`);
+    expect(replacement?.disabled).not.toBe(true);
+    expect(replacement?.name).toBe(resolve(appRoot, "plugins", `${id}.mjs`));
+  }
+  // New upstream providers must remain outside the product's governed egress.
+  for (const id of [
+    "llm-deepseek",
+    "llm-deepseek-account",
+    "web-search-deepseek",
+    "web-deepseek-api",
+    "web-fetch-http",
+    "tool-plugin-manager",
+  ])
+    expect(entries.find((entry) => entry.id === id)?.disabled).toBe(true);
+});
+
+test("official composition inserts skill management with its explicit extension switch", () => {
+  const layers = officialLayers();
+  const appRoot = resolve(import.meta.dir, "..");
+  for (const enabled of [true, false]) {
+    const entries = composeEntries([
+      ...layers,
+      nativeProfile(
+        {
+          appRoot,
+          gateUrl: "http://127.0.0.1:9999",
+          model: "fixture",
+          contextWindow: 32768,
+          maxOutputTokens: 4096,
+          userExtensions: enabled,
+        },
+        defaultHostFixture,
+      ),
+    ]);
+    const management = entries.filter(
+      (entry) => entry.id === "windy-skill-library",
+    );
+    expect(management).toHaveLength(1);
+    expect(management[0]).toMatchObject({
+      disabled: !enabled,
+      name: resolve(appRoot, "plugins/skill-library/index.mjs"),
+      config: {
+        enabled,
+        defaultSkillDir: resolve(appRoot, "plugins/skills"),
+        extraDefaultSkillDirs: [],
+        draftModel: "fixture",
+        draftMaxTokens: 4096,
+      },
+    });
+  }
+});
+
+test("all declared upstream patch layers mount only the managed registry and fixed Windy preset without skipped replacements", () => {
+  const layers = officialLayers();
+  expect(layers.length).toBeGreaterThan(2);
+  const appRoot = resolve(import.meta.dir, "..");
+  for (const userExtensions of [true, false]) {
+    const warnings: string[] = [];
+    const entries = composeEntries(
+      [
+        ...layers,
+        nativeProfile(
+          {
+            appRoot,
+            gateUrl: "http://127.0.0.1:9999",
+            model: "fixture",
+            contextWindow: 32768,
+            maxOutputTokens: 4096,
+            userExtensions,
+          },
+          defaultHostFixture,
+        ),
+      ],
+      (message) => warnings.push(message),
+    );
+    expect(warnings).toEqual([]);
+    expect(
+      entries.find((entry) => entry.id === "agent-preset-registry"),
+    ).toMatchObject({
+      name: "@deepseek-ai/dsh-agent-preset-registry",
+      disabled: true,
+    });
+    const managed = entries.filter(
+      (entry) =>
+        entry.name === resolve(appRoot, "plugins/preset-registry.mjs") &&
+        entry.disabled !== true,
+    );
+    expect(managed).toHaveLength(1);
+    expect(managed[0]).toMatchObject({
+      id: "windy-agent-preset-registry",
+      config: { default: "windy" },
+    });
+    expect(
+      entries
+        .filter(
+          (entry) =>
+            entry.name === "@deepseek-ai/dsh-agent-preset" &&
+            entry.disabled !== true,
+        )
+        .map((entry) => entry.id),
+    ).toEqual(["preset-windy"]);
+  }
+});

package/template/apps/agent-server/native/profile.ts

@@ -0,0 +1,307 @@
+import { resolve } from "node:path";
+import { officePreviewPlugin } from "./office-preview.js";
+import { conversationInstructions } from "./conversation-instructions.js";
+import { projectHost } from "../project/host.js";
+import type { DshHostConfiguration } from "../host-contracts.js";
+import { hostPresetId, hostReplacements } from "./host-profile.js";
+
+/** Final deployment overlay keeps identity and shared-model routing application-owned. */
+export function nativeProfile(
+  config: {
+    appRoot: string;
+    gateUrl: string;
+    model: string;
+    contextWindow: number;
+    maxOutputTokens: number;
+    userExtensions?: boolean;
+  },
+  host: DshHostConfiguration = projectHost,
+) {
+  const presetId = hostPresetId(host);
+  const replacements = hostReplacements(host);
+  const plugins = resolve(config.appRoot, "plugins");
+  const userExtensions = config.userExtensions ?? true;
+  const toolConfig: Record<string, unknown> = {
+    "agent-instructions": { maxBytes: 32768 },
+    "tool-fs-search": { sampleOverCapGlobResults: false },
+    "tool-todo": { allowParallelInProgress: false },
+  };
+  const disable = [
+    "llm-deepseek",
+    "llm-deepseek-account",
+    "deepseek-account",
+    "web-search-deepseek",
+    "web-deepseek-api",
+    "web-fetch-http",
+    "tool-plugin-manager",
+    "account-controller",
+    "ui-settings-models",
+    "ui-settings-account",
+    "ui-settings-session-log",
+    "ui-agent-preset",
+    "agent-preset-registry",
+    "session-log-deepseek",
+    "open-in-app",
+    "settings-controller",
+    "subprocess",
+    "session-title-llm",
+    "ui-brand-official",
+    "preset-standard",
+    "preset-minimal",
+    "preset-ptc",
+    "preset-cordis",
+    // First parallel slice uses fresh, managed children, with one fixed preset.
+    "tool-subagent-fork",
+    "tool-workflow",
+    ...replacements,
+  ];
+  return [
+    ...disable.map((id) => ({ id, disabled: true })),
+    ...[
+      "plugin-manager",
+      "hmr",
+      "client-hmr",
+      "config-editor",
+      "settings",
+      "ui-plugin-manager",
+      "ui-settings-plugin-inventory",
+      "ui-settings-plugins",
+    ].map((id) => ({ id, disabled: !userExtensions })),
+    {
+      id: "llm-pi-ai",
+      config: {
+        providers: {
+          windy: {
+            api: "openai-completions",
+            apiKeyEnv: "WINDY_WORKER_TOKEN",
+            baseURL: `${config.gateUrl}/v1`,
+            timeoutMs: 120000,
+            streamIdleTimeoutMs: 30000,
+            retryPolicy: { mode: "normal", maxRetries: 0 },
+            compat: {
+              supportsDeveloperRole: false,
+              maxTokensField: "max_tokens",
+            },
+            models: [
+              {
+                id: config.model,
+                contextWindow: config.contextWindow,
+                maxTokens: config.maxOutputTokens,
+                input: ["text", "image"],
+              },
+            ],
+          },
+        },
+      },
+    },
+    {
+      id: "agent-default-model",
+      config: { provider: "windy", model: config.model },
+    },
+    { id: "agent-loop", config: { agents: [], maxParallelToolCalls: 1 } },
+    { id: "locale", config: { preference: "zh" } },
+    officePreviewPlugin(),
+    { id: "subagent", config: { maxDepth: 1, maxActiveSubagents: 2 } },
+    {
+      id: "tool-subagent",
+      config: {
+        provider: "spawn",
+        toolName: "subagent",
+        agentPreset: presetId,
+        maxDepth: 1,
+        modelSelectionSettings: false,
+      },
+    },
+    {
+      id: "web-runtime",
+      config: {
+        openBrowser: false,
+        printUrl: false,
+        publicUrl: process.env.WINDY_PUBLIC_URL,
+        surfaceContext: true,
+      },
+    },
+    {
+      id: "workspace-controller",
+      config: { documentsDirectory: process.cwd() },
+    },
+    {
+      id: "permission",
+      config: {
+        presets: {
+          "read-only": { sandbox: "read-only", approval: "ask" },
+          "workspace-write": { sandbox: "workspace-write", approval: "ask" },
+        },
+      },
+    },
+    { id: "sandbox", config: {} },
+    {
+      insert: [
+        {
+          id: "windy-agent-preset-registry",
+          name: resolve(plugins, "preset-registry.mjs"),
+          config: { default: presetId },
+        },
+        {
+          id: "windy-skill-library",
+          disabled: !userExtensions,
+          name: resolve(plugins, "skill-library", "index.mjs"),
+          config: {
+            enabled: userExtensions,
+            defaultSkillDir: resolve(plugins, "skills"),
+            extraDefaultSkillDirs: host.skillDirectories.map((directory) =>
+              resolve(config.appRoot, directory),
+            ),
+            draftModel: config.model,
+            draftMaxTokens: Math.min(config.maxOutputTokens, 8192),
+          },
+        },
+        {
+          id: "windy-settings-controller",
+          name: resolve(plugins, "settings-controller.mjs"),
+        },
+        // Retain the deployment fence even for wider approved DSH modes.
+        { id: "windy-subprocess", name: resolve(plugins, "subprocess.mjs") },
+        {
+          id: "windy-access",
+          name: resolve(plugins, "access.mjs"),
+          config: { presetId },
+        },
+        {
+          id: "windy-shared-skills",
+          name: resolve(plugins, "shared-skills.mjs"),
+        },
+        {
+          id: "windy-tool-catalog",
+          name: resolve(plugins, "tool-catalog", "index.mjs"),
+        },
+        {
+          id: "windy-tool-presentation",
+          name: resolve(plugins, "tool-presentation", "index.mjs"),
+        },
+        {
+          id: "windy-skill-presentation",
+          name: resolve(plugins, "skill-library", "presentation", "index.mjs"),
+        },
+        {
+          id: "windy-drop-overlay",
+          name: resolve(plugins, "drop-overlay", "index.mjs"),
+        },
+        {
+          id: "windy-settings",
+          name: resolve(plugins, "settings", "index.mjs"),
+        },
+        {
+          id: "windy-workspace",
+          name: resolve(plugins, "workspace", "index.mjs"),
+          config: { label: host.workspaceLabel },
+        },
+        { id: "windy-parallel", name: resolve(plugins, "parallel.mjs") },
+        {
+          id: "windy-locale",
+          name: resolve(plugins, "locale", "index.mjs"),
+        },
+        {
+          id: "windy-theme",
+          name: resolve(plugins, "theme", "index.mjs"),
+        },
+        {
+          id: "windy-branding",
+          name: resolve(plugins, "branding", "index.mjs"),
+        },
+        {
+          id: "windy-downloads",
+          name: resolve(plugins, "downloads", "index.mjs"),
+        },
+        ...host.plugins.map((plugin) => ({
+          id: `project-${plugin.key}`,
+          name: resolve(config.appRoot, plugin.path),
+          ...(plugin.config ? { config: plugin.config } : {}),
+        })),
+        {
+          id: `preset-${presetId}`,
+          name: "@deepseek-ai/dsh-agent-preset",
+          config: {
+            id: presetId,
+            name: host.assistantName,
+            description: host.assistantDescription,
+            order: 1,
+            plugins: [
+              {
+                id: "persona",
+                name: "@deepseek-ai/dsh-persona",
+                config: {
+                  prefix: [conversationInstructions, ...host.instructions].join(
+                    "\n",
+                  ),
+                },
+              },
+              ...[
+                "agent-instructions",
+                "tool-bash",
+                "tool-fs",
+                "tool-fs-search",
+                "tool-skill",
+                "tool-ask-user",
+                "tool-todo",
+                "tool-present",
+              ].map((id) => ({
+                id,
+                name: `@deepseek-ai/dsh-${id}`,
+                ...(toolConfig[id] ? { config: toolConfig[id] } : {}),
+              })),
+              {
+                id: "skill-filesystem",
+                name: "@deepseek-ai/dsh-skill-filesystem",
+                config: {
+                  includeDefaultRoots: userExtensions,
+                  customSkillDirs: [
+                    resolve(plugins, "skills"),
+                    ...host.skillDirectories.map((path) =>
+                      resolve(config.appRoot, path),
+                    ),
+                  ],
+                },
+              },
+              {
+                id: "compaction",
+                name: "cordis:group",
+                group: true,
+                isolate: { compaction: true, toolResultPruner: true },
+                config: [
+                  {
+                    id: "compaction-basic",
+                    name: resolve(plugins, "compaction.mjs"),
+                    config: {
+                      headroomTokens: Math.min(
+                        2048,
+                        Math.floor(config.contextWindow / 8),
+                      ),
+                      maxTokens: Math.min(1024, config.maxOutputTokens),
+                      thresholdRatio: 0.8,
+                      retainRatio: 0.16,
+                      compactionRetries: 0,
+                    },
+                  },
+                  {
+                    id: "tool-result-pruner",
+                    name: "@deepseek-ai/dsh-compaction-tool-result-pruner",
+                    config: {
+                      thresholdChars: 4096,
+                      headChars: 2048,
+                      tailChars: 512,
+                    },
+                  },
+                  {
+                    id: "command-compact",
+                    name: "@deepseek-ai/dsh-command-compact",
+                  },
+                ],
+              },
+            ],
+          },
+        },
+      ],
+    },
+  ];
+}

package/template/apps/agent-server/native/request.ts

@@ -0,0 +1,61 @@
+import { request as httpRequest } from "node:http";
+
+/** node:http preserves the explicit virtual Host required by DSH cookie audiences. */
+export function nativeRequest(
+  url: string,
+  input: {
+    method?: string;
+    headers: Headers;
+    body?: ArrayBuffer;
+    signal: AbortSignal;
+  },
+): Promise<Response> {
+  const target = new URL(url);
+  if (target.protocol !== "http:" || target.hostname !== "127.0.0.1")
+    throw new Error("Invalid native transport target");
+  const headers: Record<string, string> = {};
+  input.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return new Promise((accept, reject) => {
+    const pending = httpRequest(
+      target,
+      { method: input.method ?? "GET", headers, signal: input.signal },
+      (incoming) => {
+        const result = new Headers();
+        for (let index = 0; index < incoming.rawHeaders.length; index += 2)
+          result.append(
+            incoming.rawHeaders[index]!,
+            incoming.rawHeaders[index + 1]!,
+          );
+        const iterator = incoming[Symbol.asyncIterator]();
+        const body = new ReadableStream<Uint8Array>({
+          async pull(controller) {
+            try {
+              const next = await iterator.next();
+              if (next.done) controller.close();
+              else controller.enqueue(next.value);
+            } catch (error) {
+              controller.error(error);
+            }
+          },
+          cancel() {
+            incoming.destroy();
+          },
+        });
+        const status = incoming.statusCode ?? 502;
+        accept(
+          new Response(
+            [204, 205, 304].includes(status) || input.method === "HEAD"
+              ? null
+              : body,
+            { status, headers: result },
+          ),
+        );
+      },
+    );
+    pending.once("error", reject);
+    if (input.body) pending.write(Buffer.from(input.body));
+    pending.end();
+  });
+}