flavor-code 1.2.8 → 1.2.10

package/dist/tools/runtime.d.ts

@@ -19,6 +19,7 @@ export interface ToolRuntimeOptions {
     workspace?: string;
     /** Inline tool-result content budgets. */
     outputLimits?: Partial<ToolOutputLimits>;
+    afterSuccess?(tool: string, paths: readonly string[], input: unknown, output: unknown, context: ToolContext): Promise<readonly string[]>;
 }
 export interface ToolOutputLimits {
     perToolChars: number;
@@ -55,4 +56,5 @@ export declare class ToolRuntime {
     label(call: ToolCall): string | undefined;
     hint(call: ToolCall): string | undefined;
     execute(call: ToolCall, context: ToolContext): Promise<ToolResult>;
+    callPresentation(call: ToolCall): import("./types.js").ToolPresentation | undefined;
 }

package/dist/tools/shell.d.ts

@@ -1,16 +1,21 @@
 import { z } from "zod";
 import type { ToolDefinition } from "./types.js";
 import type { ExecutionEnvironment } from "../execution/types.js";
+import type { JobRegistry } from "../jobs/registry.js";
 export declare const DEFAULT_MAX_OUTPUT_BYTES = 1048576;
+export declare const DEFAULT_SHELL_TIMEOUT_MS: number;
 declare const ShellInput: z.ZodObject<{
     command: z.ZodString;
     args: z.ZodArray<z.ZodString>;
     cwd: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     timeoutMs: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    background: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export interface ShellToolOptions {
     maxOutputBytes?: number;
+    defaultTimeoutMs?: number;
     executionEnvironment?: ExecutionEnvironment;
+    jobs?: JobRegistry;
 }
 export interface TruncationMetadata {
     truncated: boolean;
@@ -29,9 +34,14 @@ export interface ShellResult {
     };
     terminationReason: "timeout" | "cancelled" | null;
 }
-type ShellTool = Omit<ToolDefinition<z.infer<typeof ShellInput>>, "execute"> & {
-    execute(input: z.infer<typeof ShellInput>, signal: AbortSignal): Promise<ShellResult>;
+export interface ShellBackgroundResult extends ShellResult {
+    jobId: string;
+    state: "running";
+    command: string;
+}
+type ShellTool = Omit<ToolDefinition<z.infer<typeof ShellInput>, ShellResult | ShellBackgroundResult>, "execute"> & {
+    execute(input: z.infer<typeof ShellInput>, signal: AbortSignal, context?: import("./types.js").ToolContext): Promise<ShellResult | ShellBackgroundResult>;
 };
 export declare function createShellTool(workspace: string, options?: ShellToolOptions): ShellTool;
-export declare function executeShell(root: string, input: z.infer<typeof ShellInput>, cancellation: AbortSignal, maxBytes: number): Promise<ShellResult>;
+export declare function executeShell(root: string, input: z.infer<typeof ShellInput>, cancellation: AbortSignal, maxBytes: number, onOutput?: (stream: "stdout" | "stderr", text: string) => void): Promise<ShellResult>;
 export {};

package/dist/tools/terminal.d.ts

@@ -0,0 +1,3 @@
+import type { TerminalService } from "../terminal/service.js";
+import type { ToolDefinition } from "./types.js";
+export declare function createTerminalTools(terminals: TerminalService, workspace?: string): ToolDefinition<unknown>[];

package/dist/tools/types.d.ts

@@ -14,14 +14,75 @@ export interface FileChangePresentation {
     added: number;
     removed: number;
     lines: FileDiffLine[];
+    /** Additional files changed by the same atomic multi-file operation. */
+    relatedChanges?: readonly FileChangePresentation[];
 }
-export type ToolPresentation = FileChangePresentation;
+export interface ChangeSetPresentation {
+    kind: "changeset";
+    files: readonly {
+        path: string;
+        operation: "create" | "update" | "delete";
+        added: number;
+        removed: number;
+    }[];
+}
+export interface GenericToolPresentation {
+    kind: "generic";
+    title: string;
+    summary?: string;
+    details?: string;
+}
+export interface TerminalToolPresentation {
+    kind: "terminal";
+    variant?: "command" | "terminal";
+    title: string;
+    command?: string;
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number | null;
+    state?: "running" | "completed" | "failed" | "cancelled";
+    truncated?: boolean;
+}
+export interface WebToolPresentation {
+    kind: "web";
+    title: string;
+    url?: string;
+    summary?: string;
+    items?: readonly {
+        title: string;
+        url: string;
+        snippet?: string;
+    }[];
+}
+export interface JobToolPresentation {
+    kind: "job";
+    action: "start" | "list" | "read" | "wait" | "kill";
+    id?: string;
+    jobKind?: string;
+    label?: string;
+    state?: "running" | "completed" | "failed" | "cancelled";
+    exitCode?: number | null;
+    error?: string;
+    output?: string;
+    cursor?: number;
+    truncated?: boolean;
+    jobs?: readonly {
+        id: string;
+        kind: string;
+        label: string;
+        state: "running" | "completed" | "failed" | "cancelled";
+        exitCode?: number | null;
+    }[];
+}
+export type ToolPresentation = ChangeSetPresentation | FileChangePresentation | GenericToolPresentation | TerminalToolPresentation | WebToolPresentation | JobToolPresentation;
 export declare function withToolPresentation<T extends object>(output: T, presentation: ToolPresentation): T;
-export declare function getToolPresentation(output: unknown): ToolPresentation | undefined;
-export interface ToolDefinition<T> {
+export declare function getToolPresentation(output: unknown): FileChangePresentation | undefined;
+export interface ToolDefinition<T, O = unknown> {
     name: string;
     description: string;
     inputSchema: z.ZodType<T>;
+    /** Optional validation for the canonical value produced by execute. */
+    outputSchema?: z.ZodType<O>;
     /** Restrict a tool to selected agent roles. Omit to expose it to both roles. */
     agents?: readonly ToolContext["agent"][];
     /** Optional provider-facing JSON Schema when it must differ from runtime validation. */
@@ -34,8 +95,14 @@ export interface ToolDefinition<T> {
      * Must return plain text (no ANSI escapes). Return undefined or an empty string to omit the hint.
      */
     summarize?(input: T): string | undefined;
+    /** Stable, model-facing serialization. Runtime output budgets are applied to this text. */
+    renderForModel?(output: O, input: T): string;
+    /** Renderer-neutral presentation available as soon as the call starts. */
+    presentCall?(input: T): ToolPresentation | undefined;
+    /** Renderer-neutral presentation of a completed call. */
+    presentResult?(output: O, input: T): ToolPresentation | undefined;
     permissions?(input: T): ToolPermissionMetadata;
-    execute(input: T, signal: AbortSignal): Promise<unknown>;
+    execute(input: T, signal: AbortSignal, context?: ToolContext): Promise<O>;
 }
 export interface ToolCall {
     name: string;
@@ -43,12 +110,17 @@ export interface ToolCall {
 }
 export interface ToolContext {
     agent: "main" | "subagent";
+    ownerId?: string;
     signal?: AbortSignal;
 }
 export interface ToolResult {
     ok: boolean;
     output?: unknown;
+    /** Bounded model-facing content when the tool opts into the standard protocol. */
+    content?: string;
     presentation?: ToolPresentation;
+    /** Context discovered as a consequence of this successful call. */
+    additionalContext?: readonly string[];
     error?: {
         code: string;
         message: string;

package/dist/tools/web.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+declare const WebFetchInput: z.ZodObject<{
+    url: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    maxBytes: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const WebSearchInput: z.ZodObject<{
+    query: z.ZodString;
+    maxResults: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export interface WebFetchResult {
+    url: string;
+    status: number;
+    contentType: string;
+    content: string;
+    truncated: boolean;
+}
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+}
+export interface WebSearchResponse {
+    query: string;
+    results: WebSearchResult[];
+}
+export interface WebSearchProvider {
+    search(query: string, maxResults: number, signal: AbortSignal): Promise<readonly WebSearchResult[]>;
+}
+export declare function createWebFetchTool(): ToolDefinition<z.infer<typeof WebFetchInput>, WebFetchResult>;
+export declare function createWebSearchTool(provider?: WebSearchProvider): ToolDefinition<z.infer<typeof WebSearchInput>, WebSearchResponse>;
+type WebFetcher = (initialUrl: string, options: {
+    signal: AbortSignal;
+    timeoutMs: number;
+    maxBytes: number;
+    rawHtml?: boolean;
+}) => Promise<WebFetchResult>;
+export declare function createDefaultWebSearchProvider(fetcher?: WebFetcher): WebSearchProvider;
+export declare function fetchPublic(initialUrl: string, options: {
+    signal: AbortSignal;
+    timeoutMs: number;
+    maxBytes: number;
+    rawHtml?: boolean;
+}): Promise<WebFetchResult>;
+export declare function isBlockedResolvedAddress(input: string, hostname: string): boolean;
+export declare function isBlockedAddress(input: string, options?: {
+    allowBenchmarkCarrier?: boolean;
+}): boolean;
+export declare function htmlToText(html: string): string;
+export declare function parseDuckDuckGo(html: string): WebSearchResult[];
+export declare function parseBing(html: string): WebSearchResult[];
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flavor-code",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "author": "YachuanWzh",
   "type": "module",
   "publishConfig": {
@@ -46,14 +46,19 @@
     "desktop:dist": "npm run build && electron-builder --win nsis",
     "test": "vitest run",
     "test:watch": "vitest",
+    "test:desktop:e2e": "npm run build:desktop && node tests/desktop/electron-app.e2e.mjs",
     "typecheck": "tsc --noEmit",
     "smoke:install": "node scripts/smoke-install.mjs",
+    "smoke:d2c-worker": "npm run build:desktop:main && node scripts/smoke-d2c-worker.mjs",
     "prepack": "npm run build"
   },
   "build": {
     "appId": "dev.flavorcode.desktop",
     "productName": "Flavor Code",
     "asar": true,
+    "asarUnpack": [
+      "dist/desktop/pixel-worker.js"
+    ],
     "icon": "assets/icon",
     "directories": {
       "output": "release"
@@ -97,7 +102,10 @@
     "ink": "^7.1.0",
     "lodash-es": "^4.17.23",
     "marked": "^16.4.2",
+    "node-pty": "^1.1.0",
     "openai": "^6.46.0",
+    "pixelmatch": "^7.2.0",
+    "pngjs": "^7.0.0",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "semver": "^7.7.4",
@@ -110,12 +118,14 @@
   },
   "devDependencies": {
     "@types/node": "^26.1.1",
+    "@types/pngjs": "^6.0.5",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "@types/vscode": "1.95.0",
     "@vscode/vsce": "3.9.2",
     "electron": "^42.7.0",
     "electron-builder": "^26.15.3",
+    "playwright-core": "^1.62.1",
     "sharp": "^0.35.3",
     "tsup": "^8.5.1",
     "vite": "^8.1.5",
@@ -124,6 +134,7 @@
   "allowScripts": {
     "electron-winstaller@5.4.0": true,
     "esbuild@0.27.7": true,
-    "electron@42.7.0": true
+    "electron@42.7.0": true,
+    "node-pty@1.1.0": true
   }
 }