@hhuangpanda/dsh-automation 0.0.0-stage → 0.3.34

package/lib/agent-configuration.js

@@ -0,0 +1,217 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { standingMountFor } from '@deepseek-ai/dsh-agent-preset-registry';
+import { isUserInvocable, renderSkillContent } from '@deepseek-ai/dsh-skill';
+import { assertProviderModelPair, validateReasoningExecution } from './validation.js';
+import '@deepseek-ai/dsh-agent-preset-registry';
+import '@deepseek-ai/dsh-llm';
+import '@deepseek-ai/dsh-permission-presets';
+import '@deepseek-ai/dsh-skill';
+export class AgentConfiguration {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async options(cwd, agentPreset, provider, model) {
+        assertProviderModelPair(provider, model);
+        let reasoning;
+        if (provider && model) {
+            try {
+                const info = await this.ctx.llm.resolveModelInfo(provider, model);
+                reasoning = {
+                    provider, model,
+                    efforts: info.reasoning?.efforts.map(({ id, name, description }) => ({ id, name, ...(description === undefined ? {} : { description }) })) ?? [],
+                    ...(info.reasoning?.defaultEffort === undefined ? {} : { defaultEffort: info.reasoning.defaultEffort }),
+                };
+            }
+            catch (error) {
+                reasoning = { provider, model, efforts: [], error: message(error) };
+            }
+        }
+        const presets = await this.ctx.agentPresets.list();
+        const providers = this.ctx.llm.listProviders();
+        const modelResults = await Promise.all(providers.map(async (provider) => {
+            try {
+                const models = await this.ctx.llm.listModels(provider.id);
+                return { provider, models };
+            }
+            catch (error) {
+                return { provider, error: message(error) };
+            }
+        }));
+        let skills = [];
+        const candidatePreset = presets.find((preset) => preset.id === (agentPreset ?? this.ctx.agentPresets.defaultId));
+        if (candidatePreset !== undefined && candidatePreset.broken === undefined) {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const scope = __addDisposableResource(env_1, await this.ctx.agentPresets.acquireScope(agentPreset), true);
+                skills = (await this.ctx.skills.list({ cwd, scope: scope.key })).filter(isUserInvocable);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
+            }
+        }
+        return {
+            ...(reasoning === undefined ? {} : { reasoning }),
+            presets: presets.map((preset) => ({
+                id: preset.id,
+                name: preset.name ?? preset.id,
+                ...(preset.description === undefined ? {} : { description: preset.description }),
+                ...(preset.broken === undefined ? {} : { broken: preset.broken }),
+                default: preset.id === this.ctx.agentPresets.defaultId,
+            })),
+            models: modelResults.flatMap((result) => result.models === undefined ? [] : [{
+                    provider: result.provider.id,
+                    name: result.provider.name,
+                    models: result.models.map((model) => ({
+                        id: model.id,
+                        name: model.name,
+                        ...(model.description === undefined ? {} : { description: model.description }),
+                    })),
+                }]),
+            modelFailures: modelResults.flatMap((result) => result.error === undefined ? [] : [{ provider: result.provider.id, error: result.error }]),
+            permissions: this.ctx.permissionPresets.names.map((id) => {
+                const option = this.ctx.permissionPresets.optionOf(id);
+                const preset = this.ctx.permissionPresets.resolve(id);
+                return {
+                    id,
+                    name: option.name,
+                    ...(option.description === undefined ? {} : { description: option.description }),
+                    sandbox: preset.sandbox,
+                    approval: preset.approval,
+                    default: id === this.ctx.permissionPresets.defaultPreset,
+                };
+            }),
+            skills: skills.map((skill) => ({
+                name: skill.name,
+                description: skill.description,
+                ...(skill.whenToUse === undefined ? {} : { whenToUse: skill.whenToUse }),
+                modelInvocable: skill.invocation.modelInvocable,
+                source: skill.source,
+                provider: skill.provider,
+            })),
+        };
+    }
+    permissionName(permissionPreset) {
+        if (!this.ctx.permissionPresets.names.includes(permissionPreset))
+            return undefined;
+        return this.ctx.permissionPresets.optionOf(permissionPreset).name;
+    }
+    async validate(execution, permissionPreset, options = {}) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (execution.target?.mode === 'pinned-session') {
+                execution = { ...execution, agentPreset: undefined, provider: undefined, model: undefined, reasoningEffort: undefined, skills: [] };
+            }
+            const preset = await this.ctx.agentPresets.resolve(execution.agentPreset);
+            if (preset.broken !== undefined)
+                throw new Error(`Agent preset ${preset.id} is unavailable: ${preset.broken}`);
+            assertProviderModelPair(execution.provider, execution.model, { allowLegacyPartialModel: options.allowLegacyPartialModel === true });
+            validateReasoningExecution(execution);
+            if (execution.provider !== undefined && execution.model !== undefined) {
+                await this.ctx.llm.resolveCallConfig({
+                    provider: execution.provider, model: execution.model,
+                    ...(execution.reasoningEffort === undefined ? {} : { reasoningEffort: ReasoningEffortId(execution.reasoningEffort) }),
+                });
+            }
+            const scope = __addDisposableResource(env_2, await this.ctx.agentPresets.acquireScope(execution.agentPreset), true);
+            for (const name of execution.skills) {
+                const skill = await this.ctx.skills.get(name, { cwd: execution.cwd, scope: scope.key });
+                if (skill === undefined)
+                    throw new Error(`Selected skill ${name} is unavailable.`);
+                if (!isUserInvocable(skill))
+                    throw new Error(`Selected skill ${name} is not user-invocable.`);
+            }
+            this.ctx.permissionPresets.resolve(permissionPreset);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
+    }
+    async loadSelectedSkills(agent, task) {
+        if (task.execution.skills.length === 0)
+            return [];
+        const skills = this.ctx.agentPresets.serviceFor(agent, 'skills') ?? this.ctx.skills;
+        const scope = standingMountFor(agent.ctx)?.key;
+        const loaded = [];
+        for (const name of task.execution.skills) {
+            const skill = await skills.get(name, { cwd: task.execution.cwd, scope });
+            if (skill === undefined)
+                throw new Error(`Selected skill ${name} is unavailable.`);
+            if (!isUserInvocable(skill))
+                throw new Error(`Selected skill ${name} is not user-invocable.`);
+            loaded.push({
+                text: renderSkillContent(skill),
+                source: { kind: 'skill-invocation', name, form: 'instructions' },
+            });
+        }
+        return loaded;
+    }
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=agent-configuration.js.map

package/lib/api.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { AutomationController } from './controller.js';
+import '@deepseek-ai/dsh-host-webserver';
+export declare function registerAutomationApi(ctx: Context, controller: AutomationController): () => void;
+//# sourceMappingURL=api.d.ts.map

package/lib/api.js

@@ -0,0 +1,253 @@
+import { assertOverrideId, assertProviderModelPair, assertReasoningEffort } from './validation.js';
+import { AutomationDomainError } from './domain.js';
+import { AutomationDeliverySchema, AutomationPermissionPresetSchema, AutomationScheduleSchema, NotificationPolicySchema } from './types.js';
+import '@deepseek-ai/dsh-host-webserver';
+const API_ROOT = '/api/automation/v1';
+const MAX_BODY_BYTES = 16 * 1024;
+function send(res, status, value) {
+    const body = `${JSON.stringify(value)}\n`;
+    res.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(body),
+        'cache-control': 'no-store',
+        'x-content-type-options': 'nosniff',
+    });
+    res.end(body);
+}
+function sameOrigin(req) {
+    const origin = req.headers.origin;
+    if (origin === undefined)
+        return true;
+    try {
+        return new URL(origin).host === req.headers.host;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(req) {
+    let size = 0;
+    const chunks = [];
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > MAX_BODY_BYTES)
+            throw new Error('Request body is too large.');
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0)
+        return {};
+    const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error('Request body must be a JSON object.');
+    return value;
+}
+function parseUpdate(body, current) {
+    if (Object.keys(body).some((key) => !['name', 'prompt', 'schedule', 'notificationPolicy', 'pauseAfterConsecutiveFailures', 'permissionPreset', 'confirmPermissionChange', 'execution', 'confirmSessionTargetChange', 'delivery', 'confirmDeliveryChange'].includes(key))) {
+        throw new Error('Update body contains an unknown field.');
+    }
+    if (body.name !== undefined && typeof body.name !== 'string')
+        throw new Error('name must be a string.');
+    if (body.prompt !== undefined && typeof body.prompt !== 'string')
+        throw new Error('prompt must be a string.');
+    if (body.pauseAfterConsecutiveFailures !== undefined && typeof body.pauseAfterConsecutiveFailures !== 'boolean') {
+        throw new Error('pauseAfterConsecutiveFailures must be boolean.');
+    }
+    const delivery = body.delivery === undefined || body.delivery === null ? body.delivery : AutomationDeliverySchema.parse(body.delivery);
+    if (body.confirmDeliveryChange !== undefined && typeof body.confirmDeliveryChange !== 'boolean')
+        throw new Error('confirmDeliveryChange must be boolean.');
+    const schedule = body.schedule === undefined ? undefined : AutomationScheduleSchema.parse(body.schedule);
+    const notificationPolicy = body.notificationPolicy === undefined ? undefined : NotificationPolicySchema.parse(body.notificationPolicy);
+    const permissionPreset = body.permissionPreset === undefined ? undefined : AutomationPermissionPresetSchema.parse(body.permissionPreset);
+    if (permissionPreset !== undefined && permissionPreset !== current.security.permissionPreset && body.confirmPermissionChange !== true) {
+        throw new Error('confirmPermissionChange must be true when changing permissions.');
+    }
+    const execution = parseExecutionPatch(body.execution, current.execution);
+    if (body.confirmSessionTargetChange !== undefined && typeof body.confirmSessionTargetChange !== 'boolean') {
+        throw new Error('confirmSessionTargetChange must be boolean.');
+    }
+    return {
+        ...(delivery === undefined ? {} : { delivery }),
+        ...(body.confirmDeliveryChange === true ? { deliveryChangeConfirmed: true } : {}),
+        ...(body.name === undefined ? {} : { name: body.name }),
+        ...(body.prompt === undefined ? {} : { prompt: body.prompt }),
+        ...(schedule === undefined ? {} : { schedule }),
+        ...(notificationPolicy === undefined ? {} : { notificationPolicy }),
+        ...(body.pauseAfterConsecutiveFailures === undefined ? {} : { pauseAfterConsecutiveFailures: body.pauseAfterConsecutiveFailures }),
+        ...(permissionPreset === undefined ? {} : { permissionPreset }),
+        ...(permissionPreset === undefined || body.confirmPermissionChange !== true ? {} : { permissionChangeConfirmed: true }),
+        ...(execution === undefined ? {} : { execution: { ...execution, ...(execution.target !== undefined && body.confirmSessionTargetChange === true ? { sessionTargetConfirmed: true } : {}) } }),
+    };
+}
+function parseExecutionPatch(value, execution) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error('execution must be an object.');
+    const input = value;
+    if (Object.keys(input).length === 0)
+        throw new Error('execution must contain at least one field.');
+    if (Object.keys(input).some((key) => !['agentPreset', 'provider', 'model', 'reasoningEffort', 'skills', 'target'].includes(key))) {
+        throw new Error('execution contains an unknown field.');
+    }
+    const nullableString = (key) => {
+        const entry = input[key];
+        if (entry !== undefined && entry !== null && typeof entry !== 'string')
+            throw new Error(`execution.${key} must be a string or null.`);
+        assertOverrideId(entry, `execution.${key}`);
+        return entry;
+    };
+    const agentPreset = nullableString('agentPreset');
+    const provider = nullableString('provider');
+    const model = nullableString('model');
+    const reasoningEffort = input.reasoningEffort;
+    if (reasoningEffort !== undefined && reasoningEffort !== null && typeof reasoningEffort !== 'string')
+        throw new Error('execution.reasoningEffort must be a string or null.');
+    assertReasoningEffort(reasoningEffort);
+    assertProviderModelPair(provider, model);
+    if (input.skills !== undefined && (!Array.isArray(input.skills) || input.skills.some((name) => typeof name !== 'string'))) {
+        throw new Error('execution.skills must be an array of strings.');
+    }
+    const skills = input.skills;
+    let target;
+    if (input.target !== undefined) {
+        if (typeof input.target !== 'object' || input.target === null || Array.isArray(input.target))
+            throw new Error('execution.target must be an object.');
+        const value = input.target;
+        if (value.mode === 'fresh' && Object.keys(value).every((key) => key === 'mode'))
+            target = { mode: 'fresh' };
+        else if (value.mode === 'pinned-session' && Object.keys(value).every((key) => key === 'mode' || key === 'sessionId') && typeof value.sessionId === 'string' && value.sessionId.trim()) {
+            target = { mode: 'pinned-session', sessionId: value.sessionId, workspaceId: execution.workspaceId, cwd: execution.cwd, fallback: 'fail' };
+        }
+        else
+            throw new Error('execution.target is invalid.');
+    }
+    return {
+        ...(agentPreset === undefined ? {} : { agentPreset }),
+        ...(provider === undefined ? {} : { provider }),
+        ...(model === undefined ? {} : { model }),
+        ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+        ...(skills === undefined ? {} : { skills }),
+        ...(target === undefined ? {} : { target }),
+    };
+}
+export function registerAutomationApi(ctx, controller) {
+    return ctx.webServer.register({
+        kind: 'prefix',
+        path: API_ROOT,
+        async handler(req, res) {
+            const rejection = ctx.connection.requestRejection(req);
+            if (rejection !== undefined) {
+                send(res, rejection, { error: rejection === 401 ? 'Unauthorized' : 'Forbidden' });
+                return;
+            }
+            if (!sameOrigin(req)) {
+                send(res, 403, { error: 'Cross-origin requests are not allowed.' });
+                return;
+            }
+            if (req.method !== 'GET' && req.headers['x-dsh-automation'] !== '1') {
+                send(res, 403, { error: 'Missing Automation request header.' });
+                return;
+            }
+            const url = new URL(req.url ?? API_ROOT, 'http://localhost');
+            const suffix = url.pathname.slice(API_ROOT.length);
+            try {
+                if (req.method === 'POST' && suffix === '/notifications/read') {
+                    await controller.markNotificationsRead();
+                    send(res, 200, { read: true });
+                    return;
+                }
+                if (req.method === 'GET' && (suffix === '' || suffix === '/tasks')) {
+                    send(res, 200, { tasks: controller.list(), scheduler: controller.schedulerHealth() });
+                    return;
+                }
+                if (req.method === 'GET' && suffix === '/delivery-options') {
+                    const botId = url.searchParams.get('botId') ?? undefined;
+                    if (botId !== undefined && (!botId.trim() || botId.length > 256))
+                        throw new Error('Invalid dsh-im bot id.');
+                    send(res, 200, { options: await controller.deliveryOptions(botId) });
+                    return;
+                }
+                const runMatch = /^\/tasks\/([^/]+)\/runs\/([^/]+)$/.exec(suffix);
+                if (runMatch !== null) {
+                    if (req.method !== 'DELETE') {
+                        send(res, 405, { error: 'Method not allowed.' });
+                        return;
+                    }
+                    const [, rawTaskId = '', rawRunId = ''] = runMatch;
+                    const taskId = decodeURIComponent(rawTaskId);
+                    const runId = decodeURIComponent(rawRunId);
+                    if (![taskId, runId].every((id) => /^[A-Za-z0-9_-]{1,256}$/.test(id))) {
+                        throw new Error('Invalid automation task or run id.');
+                    }
+                    try {
+                        send(res, 200, { deleted: await controller.deleteRun(taskId, runId) });
+                    }
+                    catch (error) {
+                        if (!(error instanceof AutomationDomainError))
+                            throw error;
+                        if (error.code === 'task_not_found')
+                            send(res, 404, { error: error.message });
+                        else if (error.code === 'run_in_progress')
+                            send(res, 409, { error: error.message });
+                        else
+                            throw error;
+                    }
+                    return;
+                }
+                const match = /^\/tasks\/([^/]+)(?:\/(run|pause|resume|stop|options))?$/.exec(suffix);
+                if (match?.[1] === undefined) {
+                    send(res, 404, { error: 'Automation API route not found.' });
+                    return;
+                }
+                const id = decodeURIComponent(match[1]);
+                const action = match[2];
+                if (req.method === 'GET' && action === 'options') {
+                    const candidate = url.searchParams.has('agentPreset') ? url.searchParams.get('agentPreset') || null : undefined;
+                    const provider = url.searchParams.get('provider') ?? undefined;
+                    const model = url.searchParams.get('model') ?? undefined;
+                    assertProviderModelPair(provider, model);
+                    send(res, 200, { options: await controller.options(id, candidate, provider, model) });
+                    return;
+                }
+                if (req.method === 'PATCH' && action === undefined) {
+                    send(res, 200, { task: await controller.update(id, parseUpdate(await readJson(req), controller.get(id))) });
+                    return;
+                }
+                if (req.method === 'DELETE' && action === undefined) {
+                    const deleted = await controller.delete(id);
+                    send(res, deleted ? 200 : 404, { deleted });
+                    return;
+                }
+                if (req.method !== 'POST') {
+                    send(res, 405, { error: 'Method not allowed.' });
+                    return;
+                }
+                if (action === 'run') {
+                    send(res, 202, { run: await controller.runNow(id) });
+                    return;
+                }
+                if (action === 'stop') {
+                    send(res, 202, await controller.stop(id));
+                    return;
+                }
+                if (action === 'pause') {
+                    send(res, 200, { task: await controller.pause(id) });
+                    return;
+                }
+                if (action === 'resume') {
+                    const body = await readJson(req);
+                    if (body.runNow !== undefined && typeof body.runNow !== 'boolean')
+                        throw new Error('runNow must be boolean.');
+                    send(res, 200, { task: await controller.resume(id, { runNow: body.runNow === true }) });
+                    return;
+                }
+                send(res, 404, { error: 'Automation API route not found.' });
+            }
+            catch (error) {
+                send(res, 400, { error: error instanceof Error ? error.message : String(error) });
+            }
+        },
+    });
+}
+//# sourceMappingURL=api.js.map

package/lib/client/AutomationPanel.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { Context } from '@deepseek-ai/cordis';
+import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+type AutomationPanelProps = PropsRuntime<'shell.overlay'> & {
+    ctx: Context;
+};
+export declare function AutomationPanel({ ctx, useSessions, useWorkspaces }: AutomationPanelProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=AutomationPanel.d.ts.map

package/lib/client/EmptyState.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { t as translate } from './i18n.js';
+/** Templates offered when no automation exists yet. */
+export declare function EmptyState({ t, creating, disabled, onStart }: {
+    t: typeof translate;
+    creating: string | undefined;
+    disabled: boolean;
+    onStart: (id: string, prompt: string) => void;
+}): React.JSX.Element;
+//# sourceMappingURL=EmptyState.d.ts.map

package/lib/client/ModelSelection.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { t as translate } from './i18n.js';
+import type { SelectOption } from './shared.js';
+/** Composer-style navigation, controlled by the task draft rather than a live Session. */
+export declare function ModelSelection({ model, effort, models, efforts, disabled, modelDisabled, effortDisabled, onModel, onEffort, t }: {
+    model: string;
+    effort: string;
+    models: readonly SelectOption[];
+    efforts: readonly SelectOption[];
+    disabled: boolean;
+    modelDisabled: boolean;
+    effortDisabled: boolean;
+    onModel: (value: string) => void;
+    onEffort: (value: string) => void;
+    t: typeof translate;
+}): React.JSX.Element;
+//# sourceMappingURL=ModelSelection.d.ts.map

package/lib/client/ScheduleSection.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { AutomationTaskView } from '../types.js';
+import { t as translate } from './i18n.js';
+import { type CommonRRule } from './rrule-editor.js';
+/** Keep both schedule modes while editing, and serialize only on valid submission. */
+export declare function useScheduleEditor(task: AutomationTaskView): {
+    kind: "once" | "recurring";
+    setKind: React.Dispatch<React.SetStateAction<"once" | "recurring">>;
+    onceAt: string;
+    setOnceAt: React.Dispatch<React.SetStateAction<string>>;
+    rrule: string;
+    setRrule: React.Dispatch<React.SetStateAction<string>>;
+    advancedRule: boolean;
+    setAdvancedRule: React.Dispatch<React.SetStateAction<boolean>>;
+    commonRule: CommonRRule;
+    setCommonRule: React.Dispatch<React.SetStateAction<CommonRRule>>;
+    timeZone: string;
+    setTimeZone: React.Dispatch<React.SetStateAction<string>>;
+    startAt: string;
+    setStartAt: React.Dispatch<React.SetStateAction<string>>;
+    parsedRawRule: CommonRRule | undefined;
+    scheduleChanged: boolean;
+    valid: boolean;
+    getSchedule: () => AutomationTaskView["schedule"] | undefined;
+};
+/** One-time and recurring controls share the form's schedule draft. */
+export declare function ScheduleSection({ schedule, saving, t }: {
+    schedule: ReturnType<typeof useScheduleEditor>;
+    saving: boolean;
+    t: typeof translate;
+}): React.JSX.Element;
+//# sourceMappingURL=ScheduleSection.d.ts.map

package/lib/client/SchedulerHealth.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { AutomationSchedulerHealth } from '../types.js';
+import type { t as translate } from './i18n.js';
+/** Scheduler state as a dot whose hover card carries every health field. */
+export declare function SchedulerHealth({ health, locale, t }: {
+    health: AutomationSchedulerHealth | undefined;
+    locale: string;
+    t: typeof translate;
+}): React.JSX.Element | null;
+//# sourceMappingURL=SchedulerHealth.d.ts.map

package/lib/client/SkillPicker.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { AgentConfigurationOptions } from '../types.js';
+import { t as translate } from './i18n.js';
+/**
+ * Filterable skill picker showing each skill's description and invocability,
+ * with the current selection restated as removable chips.
+ */
+export declare function SkillPicker({ skills, options, disabled, t, onChange }: {
+    skills: readonly string[];
+    options: AgentConfigurationOptions | undefined;
+    disabled: boolean;
+    t: typeof translate;
+    onChange: (next: string[]) => void;
+}): React.JSX.Element;
+//# sourceMappingURL=SkillPicker.d.ts.map

package/lib/client/TaskDetail.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { AutomationTaskView } from '../types.js';
+import { t as translate } from './i18n.js';
+/** Human sentence for a task's schedule, whichever kind it is. */
+export declare function scheduleLabel(task: AutomationTaskView, locale: string, t: typeof translate): string;
+/** Display name for a permission preset, preferring the Host's own label. */
+export declare function permissionLabel(preset: string, t: typeof translate, displayName?: string): string;
+/** Callbacks the detail pane needs from the panel. */
+export interface TaskDetailActions {
+    run: () => void;
+    stop: () => void;
+    pause: () => void;
+    resume: (runNow: boolean) => void;
+    edit: () => void;
+    requestDelete: () => void;
+    requestDeleteRun: (run: AutomationTaskView['runs'][number], trigger: HTMLButtonElement) => void;
+    openSession: (sessionId: SessionId) => void;
+    back: () => void;
+}
+/**
+ * A focused overview with run history and configuration available on demand.
+ * @param props.task - the selected automation.
+ * @param props.pending - a write for this task is in flight.
+ * @returns the detail pane.
+ */
+export declare function TaskDetail({ task, locale, t, pending, actions }: {
+    task: AutomationTaskView;
+    locale: string;
+    t: typeof translate;
+    pending: boolean;
+    actions: TaskDetailActions;
+}): React.JSX.Element;
+//# sourceMappingURL=TaskDetail.d.ts.map

package/lib/client/TaskEditor.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import type { SessionListState } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { AutomationDelivery, AutomationExecutionPatch, AutomationTaskView } from '../types.js';
+import { t as translate } from './i18n.js';
+/** The PATCH body shape the controller accepts. */
+export type TaskUpdateBody = Partial<Pick<AutomationTaskView, 'name' | 'prompt' | 'schedule' | 'notificationPolicy' | 'pauseAfterConsecutiveFailures'>> & {
+    permissionPreset?: AutomationTaskView['security']['permissionPreset'];
+    confirmPermissionChange?: true;
+    confirmSessionTargetChange?: true;
+    delivery?: AutomationDelivery | null;
+    confirmDeliveryChange?: true;
+    execution?: Omit<AutomationExecutionPatch, 'target' | 'sessionTargetConfirmed'> & {
+        target?: {
+            mode: 'fresh';
+        } | {
+            mode: 'pinned-session';
+            sessionId: string;
+        };
+    };
+};
+/**
+ * Edit one automation in place in the detail pane.
+ * @param props.task - the automation being edited.
+ * @param props.saving - a write is in flight; every control locks.
+ * @returns the editor form.
+ */
+export declare function TaskEditor({ task, sessions, workspaceSessionIds, refreshSessions, saving, t, onSave, onCancel, onDirtyChange }: {
+    task: AutomationTaskView;
+    sessions: SessionListState;
+    workspaceSessionIds: readonly string[];
+    refreshSessions: () => Promise<void>;
+    saving: boolean;
+    t: typeof translate;
+    onSave: (body: TaskUpdateBody) => void;
+    onCancel: () => void;
+    onDirtyChange?: (dirty: boolean) => void;
+}): React.JSX.Element;
+//# sourceMappingURL=TaskEditor.d.ts.map

package/lib/client/TaskRow.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { AutomationTaskView } from '../types.js';
+import type { t as translate } from './i18n.js';
+/** One scannable row in the master list. */
+export declare function TaskRow({ task, locale, t, selected, onSelect }: {
+    task: AutomationTaskView;
+    locale: string;
+    t: typeof translate;
+    selected: boolean;
+    onSelect: () => void;
+}): React.JSX.Element;
+//# sourceMappingURL=TaskRow.d.ts.map