@gajae-code/coding-agent 0.2.3 → 0.2.5

package/dist/types/modes/theme/theme.d.ts

@@ -186,6 +186,7 @@ export interface ThemeInfo {
 }
 export declare function getAvailableThemesWithPaths(): Promise<ThemeInfo[]>;
 export declare function getThemeByName(name: string): Promise<Theme | undefined>;
+export declare function getDetectedThemeSettingsPath(): "theme.dark" | "theme.light";
 export declare var theme: Theme;
 /** Get the name of the currently active theme. */
 export declare function getCurrentThemeName(): string | undefined;
@@ -198,6 +199,10 @@ export declare function previewTheme(name: string): Promise<{
     success: boolean;
     error?: string;
 }>;
+export declare function restoreThemePreview(name: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
 /**
  * Enable auto-detection mode, switching to the appropriate dark/light theme.
  */
@@ -246,11 +251,7 @@ export declare function stopThemeWatcher(): void;
  * Used by HTML export to generate CSS custom properties.
  */
 export declare function getResolvedThemeColors(themeName?: string): Promise<Record<string, string>>;
-/**
- * Check if a theme is a "light" theme by analyzing its background color luminance.
- * Loads theme JSON synchronously (built-in or custom file) and resolves userMessageBg.
- */
-export declare function isLightTheme(themeName?: string): boolean;
+export declare function isLightTheme(themeName?: string, agentDir?: string): boolean;
 /**
  * Get explicit export colors from theme JSON, if specified.
  * Returns undefined for each color that isn't explicitly set.

package/dist/types/modes/types.d.ts

@@ -70,6 +70,7 @@ export interface InteractiveModeContext {
     isInitialized: boolean;
     isBackgrounded: boolean;
     isBashMode: boolean;
+    isBashNoContext: boolean;
     toolOutputExpanded: boolean;
     todoExpanded: boolean;
     planModeEnabled: boolean;
@@ -208,6 +209,7 @@ export interface InteractiveModeContext {
     openInBrowser(urlOrPath: string): void;
     refreshSlashCommandState(cwd?: string): Promise<void>;
     showSettingsSelector(): void;
+    showThemeSelector(): void;
     showHistorySearch(): void;
     showExtensionsDashboard(): void;
     showAgentsDashboard(): void;

package/dist/types/sdk.d.ts

@@ -99,6 +99,8 @@ export interface CreateAgentSessionOptions {
     agentId?: string;
     /** Display name for the agent in IRC. Default: "main" or "sub". */
     agentDisplayName?: string;
+    /** Optional restricted bash command prefixes for read-only role agents. */
+    bashAllowedPrefixes?: string[];
     /** Optional shared agent registry for IRC routing. Default: AgentRegistry.global(). */
     agentRegistry?: AgentRegistry;
     /** Parent task ID prefix for nested artifact naming (e.g., "6-Extensions") */

package/dist/types/session/streaming-output.d.ts

@@ -41,6 +41,17 @@ export interface OutputSinkOptions {
     onChunk?: (chunk: string) => void;
     /** Minimum ms between onChunk calls. 0 = every chunk (default). */
     chunkThrottleMs?: number;
+    /**
+     * Unthrottled per-chunk callback fired *after* sanitization but *before*
+     * any throttle gating, column capping, or head/tail bookkeeping. Used by
+     * background-job substrate to record the complete process stream for the
+     * Monitor tool while keeping `onChunk` cheap for UI/progress.
+     *
+     * Receives the sanitized chunk verbatim; never receives the column-capped
+     * or minimized text. Implementations must be fast and side-effect-free
+     * relative to the sink (the sink does not catch errors from this callback).
+     */
+    onRawChunk?: (chunk: string) => void;
 }
 export interface TruncationResult {
     content: string;

package/dist/types/skill-state/active-state.d.ts

@@ -74,6 +74,7 @@ export declare function isCanonicalGjcWorkflowSkill(skill: string): skill is Can
 export declare function listActiveSkills(raw: unknown): SkillActiveEntry[];
 export declare function normalizeSkillActiveState(raw: unknown): SkillActiveState | null;
 export declare function getSkillActiveStatePaths(cwd: string, sessionId?: string): SkillActiveStatePaths;
+export declare function collapsePlanningPipeline(entries: readonly SkillActiveEntry[]): SkillActiveEntry[];
 export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string): Promise<SkillActiveState | null>;
 export declare function syncSkillActiveState(options: SyncSkillActiveStateOptions): Promise<void>;
 export interface ApplyHandoffOptions {

package/dist/types/task/types.d.ts

@@ -161,6 +161,7 @@ export interface AgentDefinition {
     autoloadSkills?: string[];
     hide?: boolean;
     forkContext?: ForkContextPolicy;
+    bashAllowedPrefixes?: string[];
     source: AgentSource;
     filePath?: string;
 }

package/dist/types/tools/bash-allowed-prefixes.d.ts

@@ -0,0 +1,5 @@
+export interface BashAllowedPrefixesCheck {
+    allowed: boolean;
+    reason?: string;
+}
+export declare function checkBashAllowedPrefixes(command: string, allowedPrefixes: readonly string[] | undefined): BashAllowedPrefixesCheck;

package/dist/types/tools/bash.d.ts

@@ -59,6 +59,30 @@ export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetai
     readonly concurrency = "exclusive";
     readonly strict = true;
     constructor(session: ToolSession);
+    /**
+     * Start a background bash job for the Monitor tool. Reuses the full Bash
+     * pipeline (interceptors, internal-URL expansion, env, cwd, timeout); the
+     * public `monitor` tool itself is ACP-gated by `AgentSession` before this
+     * helper is called. The caller-supplied `onRawLine` callback is invoked once
+     * per newline-terminated stdout chunk, between turns, so the upstream Claude
+     * Code "Each stdout line is a task-notification event" semantics are preserved
+     * through the agent's existing background-task delivery path.
+     */
+    startMonitorJob(input: {
+        command: string;
+        cwd?: string;
+        timeout?: number;
+        env?: Record<string, string>;
+    }, opts?: {
+        ownerId?: string;
+        label?: string;
+        ctx?: AgentToolContext;
+        onRawLine?: (line: string, jobId: string) => void;
+    }): Promise<{
+        jobId: string;
+        label: string;
+        commandCwd: string;
+    }>;
     execute(_toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
 }
 export interface BashRenderArgs {

package/dist/types/tools/cron.d.ts

@@ -0,0 +1,110 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from "./index";
+/** Maximum scheduled tasks per owner. Mirrors upstream Claude Code's 50-task cap. */
+export declare const MAX_CRON_TASKS_PER_OWNER = 50;
+/** Recurring tasks auto-expire 7 days after creation (mirrors upstream). */
+export declare const CRON_RECURRING_MAX_AGE_MS: number;
+declare const cronCreateSchema: z.ZodObject<{
+    cron_expression: z.ZodString;
+    prompt: z.ZodString;
+    recurring: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CronCreateParams = z.infer<typeof cronCreateSchema>;
+declare const cronListSchema: z.ZodObject<{}, z.core.$strip>;
+export type CronListParams = z.infer<typeof cronListSchema>;
+declare const cronDeleteSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type CronDeleteParams = z.infer<typeof cronDeleteSchema>;
+export interface CronJobSnapshot {
+    id: string;
+    cron_expression: string;
+    prompt: string;
+    recurring: boolean;
+    createdAt: number;
+    expiresAt?: number;
+    nextFireAt?: number;
+    humanSchedule: string;
+    ownerId?: string;
+}
+export interface CronListJobDetails {
+    id: string;
+    cron: string;
+    recurring: boolean;
+    prompt: string;
+    humanSchedule: string;
+}
+export interface CronCreateToolDetails {
+    id: string;
+    cron_expression: string;
+    recurring: boolean;
+    nextFireAt?: number;
+}
+export interface CronListToolDetails {
+    jobs: CronListJobDetails[];
+}
+export interface CronDeleteToolDetails {
+    id: string;
+    deleted: boolean;
+}
+/** Clear every schedule for an owner. Exported for tests + lifecycle teardown. */
+export declare function clearOwnerSchedules(ownerId: string | undefined): void;
+/** Reset every owner's schedule store. Test-only. */
+export declare function resetCronRegistryForTests(): void;
+export declare function validateCronExpression(expression: string): void;
+export declare function findNextCronMatchMs(expression: string, afterMs: number, deadlineMs?: number): number | undefined;
+export declare function calculateCronFireTimeMs(params: {
+    id: string;
+    cronExpression: string;
+    baseMatchMs: number;
+    recurring: boolean;
+    nowMs: number;
+    expiresAt?: number;
+}): number;
+export declare class CronCreateTool implements AgentTool<typeof cronCreateSchema, CronCreateToolDetails> {
+    private readonly session;
+    readonly name = "CronCreate";
+    readonly label = "CronCreate";
+    readonly summary = "Schedule a prompt on a 5-field cron expression";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        cron_expression: z.ZodString;
+        prompt: z.ZodString;
+        recurring: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): CronCreateTool | null;
+    execute(_toolCallId: string, params: CronCreateParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronCreateToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronCreateToolDetails>>;
+}
+export declare class CronListTool implements AgentTool<typeof cronListSchema, CronListToolDetails> {
+    private readonly session;
+    readonly name = "CronList";
+    readonly label = "CronList";
+    readonly summary = "List scheduled cron jobs";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{}, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): CronListTool | null;
+    execute(_toolCallId: string, _params: CronListParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronListToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronListToolDetails>>;
+}
+export declare class CronDeleteTool implements AgentTool<typeof cronDeleteSchema, CronDeleteToolDetails> {
+    private readonly session;
+    readonly name = "CronDelete";
+    readonly label = "CronDelete";
+    readonly summary = "Cancel a scheduled cron job by ID";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): CronDeleteTool | null;
+    execute(_toolCallId: string, params: CronDeleteParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronDeleteToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronDeleteToolDetails>>;
+}
+export {};

package/dist/types/tools/index.d.ts

@@ -32,6 +32,7 @@ export * from "./bash";
 export * from "./browser";
 export * from "./calculator";
 export * from "./checkpoint";
+export * from "./cron";
 export * from "./debug";
 export * from "./eval";
 export * from "./find";
@@ -43,6 +44,7 @@ export * from "./image-gen";
 export * from "./inspect-image";
 export * from "./irc";
 export * from "./job";
+export * from "./monitor";
 export * from "./read";
 export * from "./recipe";
 export * from "./render-mermaid";
@@ -118,6 +120,8 @@ export interface ToolSession {
     getToolByName?: (name: string) => AgentTool | undefined;
     /** Agent registry for IRC routing across live sessions. */
     agentRegistry?: AgentRegistry;
+    /** Optional restricted bash command prefixes for read-only role agents. */
+    bashAllowedPrefixes?: string[];
     /** Get artifacts directory for artifact:// URLs */
     getArtifactsDir?: () => string | null;
     /** Get the ArtifactManager backing this session (shared across parent + subagents). */

package/dist/types/tools/monitor.d.ts

@@ -0,0 +1,54 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from "./index";
+declare const monitorKindEnum: z.ZodEnum<{
+    log: "log";
+    other: "other";
+    poll: "poll";
+    watch: "watch";
+}>;
+declare const monitorSchema: z.ZodObject<{
+    command: z.ZodString;
+    kind: z.ZodEnum<{
+        log: "log";
+        other: "other";
+        poll: "poll";
+        watch: "watch";
+    }>;
+    description: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    persistent: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type MonitorParams = z.infer<typeof monitorSchema>;
+export interface MonitorToolDetails {
+    taskId: string;
+    kind: z.infer<typeof monitorKindEnum>;
+    description: string;
+    command: string;
+    persistent: boolean;
+}
+export declare class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolDetails> {
+    private readonly session;
+    readonly name = "monitor";
+    readonly label = "Monitor";
+    readonly summary = "Start a background monitor that streams stdout lines as task notifications";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        command: z.ZodString;
+        kind: z.ZodEnum<{
+            log: "log";
+            other: "other";
+            poll: "poll";
+            watch: "watch";
+        }>;
+        description: z.ZodString;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        persistent: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): MonitorTool | null;
+    execute(_toolCallId: string, params: MonitorParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<MonitorToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<MonitorToolDetails>>;
+}
+export {};

package/dist/types/web/search/index.d.ts

@@ -40,6 +40,7 @@ export declare function runSearchQuery(params: SearchQueryParams, options?: {
     authStorage?: AuthStorage;
     sessionId?: string;
     signal?: AbortSignal;
+    activeModelProvider?: string;
 }): Promise<{
     content: Array<{
         type: "text";

package/dist/types/web/search/provider.d.ts

@@ -14,8 +14,15 @@ export declare const SEARCH_PROVIDER_ORDER: SearchProviderId[];
 /** Set the preferred web search provider from settings */
 export declare function setPreferredSearchProvider(provider: SearchProviderId | "auto"): void;
 /**
- * Determine which providers are configured and currently available.
- * Each candidate is loaded (and its `isAvailable()` called) only as the chain
- * is walked, so unconfigured providers never pay the load cost.
+ * Resolve the ordered provider chain for a search request.
+ *
+ * Resolution is active-model-gated, never credential-scanning:
+ *   1. An explicitly preferred provider (settings) that is available is primary.
+ *   2. Otherwise the active model's own native search is primary, but only when
+ *      that provider's own credentials are present (its `isAvailable()`).
+ *   3. DuckDuckGo (keyless) is always appended as the terminal fallback, so a
+ *      missing primary — or a primary runtime failure — still returns results
+ *      with zero configuration. Keyed standalone providers are never
+ *      auto-selected; they are reachable only via explicit selection (step 1).
  */
-export declare function resolveProviderChain(authStorage: AuthStorage, preferredProvider?: SearchProviderId | "auto"): Promise<SearchProvider[]>;
+export declare function resolveProviderChain(authStorage: AuthStorage, preferredProvider?: SearchProviderId | "auto", activeModelProvider?: string): Promise<SearchProvider[]>;

package/dist/types/web/search/providers/duckduckgo.d.ts

@@ -0,0 +1,57 @@
+/**
+ * DuckDuckGo Web Search Provider
+ *
+ * Keyless, permissionless web search. Scrapes DuckDuckGo's no-JavaScript HTML
+ * endpoints and maps anchors/snippets into the unified SearchResponse shape
+ * (sources only — DuckDuckGo does not synthesize an answer).
+ *
+ * This is the zero-config default/fallback backend: it requires no API key and
+ * no OAuth, so `isAvailable()` is always true. Because DuckDuckGo applies
+ * anti-bot rate limiting (HTTP 202 / 403 / empty responses) from datacenter and
+ * VPN IPs, the provider is best-effort: it retries with backoff, rotates the
+ * user-agent, and alternates between the `html` and `lite` endpoints. When every
+ * attempt fails it throws a {@link SearchProviderError} rather than returning an
+ * empty success — it never falls through to keyed providers.
+ *
+ * Endpoints:
+ *   https://html.duckduckgo.com/html/  (primary)
+ *   https://lite.duckduckgo.com/lite/  (fallback markup)
+ *
+ * The HTML markup is liable to drift; the parser is deliberately small and is
+ * pinned by fixture-driven tests (see test/tools/web-search-duckduckgo.test.ts).
+ */
+import type { AuthStorage } from "@gajae-code/ai";
+import type { SearchResponse } from "../../../web/search/types";
+import type { SearchParams } from "./base";
+import { SearchProvider } from "./base";
+interface ParsedResult {
+    title: string;
+    url: string;
+    snippet?: string;
+}
+/**
+ * Resolve a DuckDuckGo result href to the real destination URL. DuckDuckGo wraps
+ * external links in a `/l/?uddg=<encoded>` redirect; `lite` sometimes links
+ * directly. Returns null for unusable or internal links (so ads/redirect shells
+ * are dropped).
+ */
+export declare function decodeResultUrl(href: string): string | null;
+/** Parse results from the `html.duckduckgo.com/html/` markup. */
+export declare function parseHtmlResults(html: string): ParsedResult[];
+/** Parse results from the `lite.duckduckgo.com/lite/` markup. */
+export declare function parseLiteResults(html: string): ParsedResult[];
+/** Execute a keyless DuckDuckGo web search with light resilience. */
+export declare function searchDuckDuckGo(params: {
+    query: string;
+    num_results?: number;
+    recency?: "day" | "week" | "month" | "year";
+    signal?: AbortSignal;
+}): Promise<SearchResponse>;
+/** Keyless, permissionless web search provider backed by DuckDuckGo. */
+export declare class DuckDuckGoProvider extends SearchProvider {
+    readonly id = "duckduckgo";
+    readonly label = "DuckDuckGo";
+    isAvailable(_authStorage: AuthStorage): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}
+export {};

package/dist/types/web/search/types.d.ts

@@ -4,7 +4,7 @@
  * Unified types for web search responses across supported providers.
  */
 /** Supported web search providers */
-export type SearchProviderId = "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng";
+export type SearchProviderId = "duckduckgo" | "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng";
 export declare function isSearchProviderId(value: string): value is SearchProviderId;
 export declare function isSearchProviderPreference(value: string): value is SearchProviderId | "auto";
 /** Source returned by search (all providers) */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.2.3",
+	"version": "0.2.5",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -48,12 +48,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.2.3",
-		"@gajae-code/agent-core": "0.2.3",
-		"@gajae-code/ai": "0.2.3",
-		"@gajae-code/natives": "0.2.3",
-		"@gajae-code/tui": "0.2.3",
-		"@gajae-code/utils": "0.2.3",
+		"@gajae-code/stats": "0.2.5",
+		"@gajae-code/agent-core": "0.2.5",
+		"@gajae-code/ai": "0.2.5",
+		"@gajae-code/natives": "0.2.5",
+		"@gajae-code/tui": "0.2.5",
+		"@gajae-code/utils": "0.2.5",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",