@kafca/agentdock 0.1.58 → 0.1.62

package/dist-electron/electron/managed-skills/knowledge-base/scripts/search-knowledge.sh

@@ -0,0 +1,80 @@
+#!/bin/sh
+set -u
+
+API_BASE="${KNOWLEDGE_API_BASE_URL:-http://127.0.0.1:9831/api/local/v1}"
+LIMIT="${KNOWLEDGE_SEARCH_LIMIT:-5}"
+
+escape_json() {
+  printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g'
+}
+
+print_results() {
+  KB_ID="$1"
+  RESPONSE="$2"
+  RESPONSE_JSON="$RESPONSE" KB_ID="$KB_ID" node <<'NODE'
+const responseText = process.env.RESPONSE_JSON || '';
+const kbId = process.env.KB_ID || 'unknown';
+
+try {
+  const payload = JSON.parse(responseText);
+  const results = Array.isArray(payload?.data?.results)
+    ? payload.data.results
+    : Array.isArray(payload?.results)
+      ? payload.results
+      : null;
+
+  if (!results) {
+    console.log('Error: invalid response payload');
+    console.log('');
+    process.exit(0);
+  }
+
+  if (results.length === 0) {
+    console.log('No results');
+    console.log('');
+    process.exit(0);
+  }
+
+  for (const item of results) {
+    const title = String(item?.title || kbId);
+    const fileName = String(item?.fileName || 'unknown');
+    const score = typeof item?.score === 'number' ? item.score : 0;
+    const snippet = String(item?.snippet || '').trim();
+    console.log(`- Title: ${title}`);
+    console.log(`  File: ${fileName}`);
+    console.log(`  Score: ${score}`);
+    console.log(`  Snippet: ${snippet || '(empty)'}`);
+  }
+  console.log('');
+} catch (error) {
+  console.log(`Error: ${error instanceof Error ? error.message : String(error)}`);
+  console.log('');
+}
+NODE
+  echo
+}
+
+if [ "$#" -lt 2 ]; then
+  echo "Usage: search-knowledge.sh \"<query>\" \"<kb_id_1>\" [kb_id_2 ...]" >&2
+  exit 1
+fi
+
+QUERY="$1"
+shift
+ESCAPED_QUERY=$(escape_json "$QUERY")
+
+for KB_ID in "$@"; do
+  echo "=== Knowledge Base: $KB_ID ==="
+  RESPONSE=$(curl -fsS -X POST "$API_BASE/knowledge/bases/$KB_ID/search" \
+    -H 'Content-Type: application/json' \
+    --data "{\"query\":\"$ESCAPED_QUERY\",\"limit\":$LIMIT}" 2>&1)
+  STATUS=$?
+
+  if [ "$STATUS" -ne 0 ]; then
+    echo "Error: $RESPONSE"
+    echo
+    continue
+  fi
+
+  print_results "$KB_ID" "$RESPONSE"
+done

package/dist-electron/packages/contracts/src/automations.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAutomationActivation = normalizeAutomationActivation;
+exports.normalizeAutomationCondition = normalizeAutomationCondition;
+exports.normalizeAutomationDefinition = normalizeAutomationDefinition;
+const local_core_js_1 = require("./local-core.js");
+function asRecord(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    return value;
+}
+function requiredString(value, label) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new Error(`${label} is required.`);
+    }
+    return value.trim();
+}
+function optionalString(value, label) {
+    if (value === undefined)
+        return undefined;
+    return requiredString(value, label);
+}
+function isoTimestamp(value, label) {
+    const normalized = requiredString(value, label);
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/.exec(normalized);
+    if (!match || Number.isNaN(Date.parse(normalized))) {
+        throw new Error(`${label} must be a valid ISO timestamp.`);
+    }
+    const [, yearText, monthText, dayText, hourText, minuteText, secondText] = match;
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    const calendarDate = new Date(Date.UTC(year, month - 1, day));
+    if (calendarDate.getUTCFullYear() !== year ||
+        calendarDate.getUTCMonth() !== month - 1 ||
+        calendarDate.getUTCDate() !== day ||
+        Number(hourText) > 23 ||
+        Number(minuteText) > 59 ||
+        Number(secondText) > 59) {
+        throw new Error(`${label} must be a valid ISO timestamp.`);
+    }
+    return normalized;
+}
+function optionalIsoTimestamp(value, label) {
+    if (value === undefined)
+        return undefined;
+    return isoTimestamp(value, label);
+}
+function nonNegativeInteger(value, label) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer.`);
+    }
+    return value;
+}
+function normalizeAutomationExecutionMode(value) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new Error('Automation action executionMode must be a non-empty string.');
+    }
+    const normalized = (0, local_core_js_1.normalizeScheduledJobExecutionMode)(value.trim());
+    if (normalized === 'same-thread')
+        return 'same-thread';
+    if (normalized === 'side-thread')
+        return 'side-thread';
+    throw new Error('Automation action executionMode must be same-thread or side-thread.');
+}
+function normalizeRoute(value) {
+    const route = asRecord(value, 'Automation delivery route');
+    const normalized = {
+        type: requiredString(route.type, 'Automation delivery route type'),
+        channelId: requiredString(route.channelId, 'Automation delivery route channelId'),
+    };
+    const instanceId = optionalString(route.instanceId, 'Automation delivery route instanceId');
+    const participantId = optionalString(route.participantId, 'Automation delivery route participantId');
+    const threadId = optionalString(route.threadId, 'Automation delivery route threadId');
+    if (instanceId)
+        normalized.instanceId = instanceId;
+    if (participantId)
+        normalized.participantId = participantId;
+    if (threadId)
+        normalized.threadId = threadId;
+    if (route.metadata !== undefined)
+        normalized.metadata = asRecord(route.metadata, 'Automation delivery route metadata');
+    return normalized;
+}
+function normalizeAutomationActivation(value) {
+    const input = asRecord(value, 'Automation activation');
+    switch (input.kind) {
+        case 'cron':
+            return {
+                kind: 'cron',
+                expression: requiredString(input.expression, 'Automation cron expression'),
+                timezone: requiredString(input.timezone, 'Automation cron timezone'),
+            };
+        case 'once':
+            return { kind: 'once', runAt: isoTimestamp(input.runAt, 'Automation runAt') };
+        case 'interval': {
+            const intervalMs = nonNegativeInteger(input.intervalMs, 'Automation intervalMs');
+            if (intervalMs === 0)
+                throw new Error('Automation intervalMs must be greater than zero.');
+            return { kind: 'interval', intervalMs };
+        }
+        case 'provider-event':
+            return {
+                kind: 'provider-event',
+                sourceType: requiredString(input.sourceType, 'Automation provider sourceType'),
+                sourceConfig: asRecord(input.sourceConfig, 'Automation provider sourceConfig'),
+            };
+        default:
+            throw new Error('Automation activation kind must be cron, once, interval, or provider-event.');
+    }
+}
+function normalizeAutomationCondition(value) {
+    const input = asRecord(value, 'Automation condition');
+    switch (input.kind) {
+        case 'always':
+            return { kind: 'always' };
+        case 'expression':
+            return { kind: 'expression', expression: requiredString(input.expression, 'Automation condition expression') };
+        case 'approved-script':
+            if (input.edge !== 'rising')
+                throw new Error('Automation approved-script edge must be rising.');
+            return {
+                kind: 'approved-script',
+                scriptId: requiredString(input.scriptId, 'Automation condition scriptId'),
+                approvedVersionId: requiredString(input.approvedVersionId, 'Automation condition approvedVersionId'),
+                edge: 'rising',
+            };
+        default:
+            throw new Error('Automation condition kind must be always, expression, or approved-script.');
+    }
+}
+function normalizeAutomationDefinition(value) {
+    const input = asRecord(value, 'Automation definition');
+    const action = asRecord(input.action, 'Automation action');
+    if (action.kind !== 'agent-prompt')
+        throw new Error('Automation action kind must be agent-prompt.');
+    const executionMode = normalizeAutomationExecutionMode(action.executionMode);
+    const delivery = asRecord(input.delivery, 'Automation delivery');
+    const policies = asRecord(input.policies, 'Automation policies');
+    if (policies.concurrency !== 'skip-if-running') {
+        throw new Error('Automation concurrency policy must be skip-if-running.');
+    }
+    if (input.health !== 'healthy' && input.health !== 'blocked') {
+        throw new Error('Automation health must be healthy or blocked.');
+    }
+    if (typeof input.enabled !== 'boolean')
+        throw new Error('Automation enabled must be a boolean.');
+    const normalized = {
+        id: requiredString(input.id, 'Automation id'),
+        workspaceId: requiredString(input.workspaceId, 'Automation workspaceId'),
+        title: requiredString(input.title, 'Automation title'),
+        enabled: input.enabled,
+        health: input.health,
+        activation: normalizeAutomationActivation(input.activation),
+        condition: normalizeAutomationCondition(input.condition),
+        action: {
+            kind: 'agent-prompt',
+            promptTemplate: requiredString(action.promptTemplate, 'Automation promptTemplate'),
+            executionMode,
+        },
+        delivery: {
+            platform: requiredString(delivery.platform, 'Automation delivery platform').toLowerCase(),
+            route: normalizeRoute(delivery.route),
+        },
+        policies: {
+            concurrency: 'skip-if-running',
+            cooldownMs: nonNegativeInteger(policies.cooldownMs, 'Automation cooldownMs'),
+        },
+        consecutiveEvaluationFailures: nonNegativeInteger(input.consecutiveEvaluationFailures, 'Automation consecutiveEvaluationFailures'),
+        createdAt: isoTimestamp(input.createdAt, 'Automation createdAt'),
+        updatedAt: isoTimestamp(input.updatedAt, 'Automation updatedAt'),
+    };
+    const blockedReason = optionalString(input.blockedReason, 'Automation blockedReason');
+    const lastEvaluationAt = optionalIsoTimestamp(input.lastEvaluationAt, 'Automation lastEvaluationAt');
+    const lastTriggeredAt = optionalIsoTimestamp(input.lastTriggeredAt, 'Automation lastTriggeredAt');
+    if (blockedReason)
+        normalized.blockedReason = blockedReason;
+    if (lastEvaluationAt)
+        normalized.lastEvaluationAt = lastEvaluationAt;
+    if (lastTriggeredAt)
+        normalized.lastTriggeredAt = lastTriggeredAt;
+    if (input.lastSuccessfulMatch !== undefined) {
+        if (typeof input.lastSuccessfulMatch !== 'boolean') {
+            throw new Error('Automation lastSuccessfulMatch must be a boolean.');
+        }
+        normalized.lastSuccessfulMatch = input.lastSuccessfulMatch;
+    }
+    if (input.originKind === 'native' ||
+        input.originKind === 'scheduled-job' ||
+        input.originKind === 'automation-monitor') {
+        normalized.originKind = input.originKind;
+    }
+    else if (input.originKind !== undefined) {
+        throw new Error('Automation originKind is invalid.');
+    }
+    if (input.legacyMetadata !== undefined) {
+        if (input.originKind !== 'scheduled-job') {
+            throw new Error('Automation legacyMetadata requires scheduled-job origin.');
+        }
+        const legacyMetadata = asRecord(input.legacyMetadata, 'Automation legacyMetadata');
+        const scheduledDescription = legacyMetadata.scheduledDescription;
+        if (scheduledDescription !== undefined && typeof scheduledDescription !== 'string') {
+            throw new Error('Automation legacy scheduledDescription must be a string.');
+        }
+        normalized.legacyMetadata = {
+            ...(scheduledDescription !== undefined ? { scheduledDescription } : {}),
+        };
+    }
+    return normalized;
+}

package/dist-electron/packages/contracts/src/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("../../../shared/desktop"), exports);
 __exportStar(require("./local-core"), exports);
+__exportStar(require("./automations"), exports);

package/dist-electron/packages/core-sdk/src/automations.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAutomations = listAutomations;
+exports.createAutomation = createAutomation;
+exports.getAutomation = getAutomation;
+exports.updateAutomation = updateAutomation;
+exports.deleteAutomation = deleteAutomation;
+exports.checkAutomation = checkAutomation;
+exports.listAutomationEvaluations = listAutomationEvaluations;
+exports.listAutomationRuns = listAutomationRuns;
+exports.listAutomationScripts = listAutomationScripts;
+exports.createAutomationScript = createAutomationScript;
+exports.getAutomationScript = getAutomationScript;
+exports.updateAutomationScript = updateAutomationScript;
+exports.listAutomationScriptVersions = listAutomationScriptVersions;
+exports.submitAutomationScriptVersion = submitAutomationScriptVersion;
+exports.requestAutomationScriptTestApproval = requestAutomationScriptTestApproval;
+exports.executeAutomationScriptTest = executeAutomationScriptTest;
+exports.requestAutomationScriptEnableApproval = requestAutomationScriptEnableApproval;
+exports.approveAutomationScriptVersion = approveAutomationScriptVersion;
+exports.rejectAutomationScriptVersion = rejectAutomationScriptVersion;
+exports.revokeAutomationScriptVersion = revokeAutomationScriptVersion;
+const request_js_1 = require("./request.js");
+function scoped(path, workspaceId) {
+    return `${path}${(0, request_js_1.buildQuery)({ workspace_id: workspaceId })}`;
+}
+function listAutomations(workspaceId) {
+    return (0, request_js_1.coreRequest)('GET', scoped('/automations', workspaceId));
+}
+function createAutomation(input) {
+    return (0, request_js_1.coreRequest)('POST', '/automations', input);
+}
+function getAutomation(automationId, workspaceId) {
+    return (0, request_js_1.coreRequest)('GET', scoped(`/automations/${encodeURIComponent(automationId)}`, workspaceId));
+}
+function updateAutomation(automationId, workspaceId, input) {
+    return (0, request_js_1.coreRequest)('PATCH', scoped(`/automations/${encodeURIComponent(automationId)}`, workspaceId), input);
+}
+function deleteAutomation(automationId, workspaceId) {
+    return (0, request_js_1.coreRequest)('DELETE', scoped(`/automations/${encodeURIComponent(automationId)}`, workspaceId));
+}
+function checkAutomation(automationId, workspaceId) {
+    return (0, request_js_1.coreRequest)('POST', scoped(`/automations/${encodeURIComponent(automationId)}/check`, workspaceId));
+}
+function listAutomationEvaluations(automationId, workspaceId) {
+    return (0, request_js_1.coreRequest)('GET', scoped(`/automations/${encodeURIComponent(automationId)}/evaluations`, workspaceId));
+}
+function listAutomationRuns(automationId, workspaceId) {
+    return (0, request_js_1.coreRequest)('GET', scoped(`/automations/${encodeURIComponent(automationId)}/runs`, workspaceId));
+}
+function listAutomationScripts(workspaceId) {
+    return (0, request_js_1.coreRequest)('GET', scoped('/automation-scripts', workspaceId));
+}
+function createAutomationScript(input) {
+    return (0, request_js_1.coreRequest)('POST', '/automation-scripts', input);
+}
+function getAutomationScript(scriptId, workspaceId) {
+    return (0, request_js_1.coreRequest)('GET', scoped(`/automation-scripts/${encodeURIComponent(scriptId)}`, workspaceId));
+}
+function updateAutomationScript(scriptId, workspaceId, input) {
+    return (0, request_js_1.coreRequest)('PATCH', scoped(`/automation-scripts/${encodeURIComponent(scriptId)}`, workspaceId), input);
+}
+function listAutomationScriptVersions(scriptId, workspaceId) {
+    return (0, request_js_1.coreRequest)('GET', scoped(`/automation-scripts/${encodeURIComponent(scriptId)}/versions`, workspaceId));
+}
+/** Uploads a bounded source bundle; the server owns staging, hash, and interpreter selection. */
+function submitAutomationScriptVersion(scriptId, workspaceId, files) {
+    return (0, request_js_1.coreRequest)('POST', scoped(`/automation-scripts/${encodeURIComponent(scriptId)}/versions`, workspaceId), { files });
+}
+function requestAutomationScriptTestApproval(versionId, workspaceId, actor) {
+    return (0, request_js_1.coreRequest)('POST', scoped(`/automation-scripts/versions/${encodeURIComponent(versionId)}/test-approval`, workspaceId), { actor });
+}
+function executeAutomationScriptTest(versionId, workspaceId, actor) {
+    return (0, request_js_1.coreRequest)('POST', scoped(`/automation-scripts/versions/${encodeURIComponent(versionId)}/test`, workspaceId), { actor });
+}
+function requestAutomationScriptEnableApproval(versionId, workspaceId, actor) {
+    return (0, request_js_1.coreRequest)('POST', scoped(`/automation-scripts/versions/${encodeURIComponent(versionId)}/enable-approval`, workspaceId), { actor });
+}
+function approveAutomationScriptVersion(versionId, workspaceId, approvalId, actor) {
+    return (0, request_js_1.coreRequest)('POST', scoped(`/automation-scripts/versions/${encodeURIComponent(versionId)}/approve`, workspaceId), { approvalId, actor });
+}
+function rejectAutomationScriptVersion(versionId, workspaceId, approvalId, actor) {
+    return (0, request_js_1.coreRequest)('POST', scoped(`/automation-scripts/versions/${encodeURIComponent(versionId)}/reject`, workspaceId), { approvalId, actor });
+}
+function revokeAutomationScriptVersion(versionId, workspaceId, actor) {
+    return (0, request_js_1.coreRequest)('POST', scoped(`/automation-scripts/versions/${encodeURIComponent(versionId)}/revoke`, workspaceId), { actor });
+}

package/dist-electron/packages/core-sdk/src/client.js

@@ -20,6 +20,10 @@ exports.LOCAL_CORE_EVENT_NAMES = [
     'scheduler.run.updated',
     'automation.monitor.updated',
     'automation.monitor.run.updated',
+    'automation.definition.updated',
+    'automation.evaluation.updated',
+    'automation.run.updated',
+    'automation.script-version.updated',
     'presence.updated',
     'stream.updated',
 ];
@@ -133,6 +137,95 @@ function isAutomationMonitorRun(value) {
         hasString(value, 'status') &&
         hasString(value, 'triggeredAt');
 }
+function isAutomationDefinition(value) {
+    return isRecord(value) && hasString(value, 'id') && hasString(value, 'workspaceId') && hasString(value, 'title') &&
+        hasBoolean(value, 'enabled') && (value.health === 'healthy' || value.health === 'blocked') &&
+        isAutomationActivation(value.activation) && isAutomationCondition(value.condition) && isAutomationAction(value.action) &&
+        isAutomationDelivery(value.delivery) && isAutomationPolicies(value.policies) &&
+        isNonNegativeInteger(value.consecutiveEvaluationFailures) &&
+        hasString(value, 'createdAt') && hasString(value, 'updatedAt') &&
+        (value.health !== 'blocked' || hasString(value, 'blockedReason')) &&
+        (value.blockedReason === undefined || typeof value.blockedReason === 'string') &&
+        (value.lastSuccessfulMatch === undefined || typeof value.lastSuccessfulMatch === 'boolean') &&
+        (value.lastEvaluationAt === undefined || typeof value.lastEvaluationAt === 'string') &&
+        (value.lastTriggeredAt === undefined || typeof value.lastTriggeredAt === 'string');
+}
+function isAutomationEvaluation(value) {
+    if (!isRecord(value) || !hasString(value, 'id') || !hasString(value, 'automationId') || !hasString(value, 'activationKind') ||
+        !['cron', 'once', 'interval', 'provider-event'].includes(String(value.activationKind)) || !hasString(value, 'status') || !hasString(value, 'startedAt'))
+        return false;
+    if (value.status === 'running') {
+        return value.conditionOutcome === undefined && value.triggerDecision === undefined && value.finishedAt === undefined &&
+            value.durationMs === undefined && value.exitCode === undefined && value.errorCategory === undefined &&
+            value.stdout === undefined && value.stderr === undefined && value.resultSummary === undefined && value.payload === undefined &&
+            value.nextState === undefined && value.sandboxViolations === undefined && value.networkAudit === undefined;
+    }
+    if (value.status !== 'finished' || !hasString(value, 'finishedAt'))
+        return false;
+    if (value.conditionOutcome === 'matched')
+        return ['triggered', 'not_rising', 'skipped_cooldown', 'skipped_action_running'].includes(String(value.triggerDecision));
+    if (value.conditionOutcome === 'not_matched')
+        return value.triggerDecision === 'not_rising';
+    if (value.conditionOutcome === 'error')
+        return value.triggerDecision === 'not_evaluated';
+    return value.conditionOutcome === 'skipped' && ['not_evaluated', 'skipped_concurrent', 'skipped_cooldown', 'skipped_action_running'].includes(String(value.triggerDecision));
+}
+function isAutomationRun(value) {
+    return isRecord(value) && hasString(value, 'id') && hasString(value, 'automationId') && hasString(value, 'evaluationId') &&
+        ['queued', 'running', 'succeeded', 'failed', 'skipped'].includes(String(value.status)) &&
+        ['same-thread', 'side-thread'].includes(String(value.executionMode)) && hasString(value, 'createdAt') &&
+        (value.deliveryStatus === undefined || ['pending', 'delivering', 'delivered', 'failed'].includes(String(value.deliveryStatus))) &&
+        (value.threadId === undefined || typeof value.threadId === 'string') && (value.acpRunId === undefined || typeof value.acpRunId === 'string') &&
+        (value.error === undefined || typeof value.error === 'string');
+}
+function isAutomationScriptVersion(value) {
+    return isRecord(value) && hasString(value, 'id') && hasString(value, 'scriptId') && hasString(value, 'status') &&
+        ['draft', 'pending_test_approval', 'test_authorized', 'testing', 'tested', 'pending_approval', 'approved', 'rejected', 'revoked'].includes(String(value.status)) &&
+        hasString(value, 'packageSha256') && hasString(value, 'packagePath') && hasString(value, 'shebang') &&
+        hasString(value, 'interpreterPath') && hasString(value, 'interpreterVersion') && isRecord(value.capabilities) &&
+        isRecord(value.config) && isRecord(value.configSchema) && (value.networkMode === 'none' || value.networkMode === 'public') &&
+        hasBoolean(value, 'internalAccess') && isStringArray(value.allowedReadDirs) && isStringArray(value.secretRefs) &&
+        isStringArray(value.env) && isRecord(value.limits) && isNonNegativeInteger(value.limits.timeoutMs) &&
+        isNonNegativeInteger(value.limits.stdoutBytes) && isNonNegativeInteger(value.limits.stderrBytes) &&
+        isNonNegativeInteger(value.limits.payloadBytes) && isNonNegativeInteger(value.limits.stateBytes) &&
+        isRecord(value.staticCheck) && isRecord(value.testPlan) && hasString(value, 'createdAt') && hasString(value, 'updatedAt');
+}
+function isAutomationActivation(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind === 'cron')
+        return hasString(value, 'expression') && hasString(value, 'timezone');
+    if (value.kind === 'once')
+        return hasString(value, 'runAt');
+    if (value.kind === 'interval')
+        return typeof value.intervalMs === 'number' && isNonNegativeInteger(value.intervalMs) && value.intervalMs > 0;
+    return value.kind === 'provider-event' && hasString(value, 'sourceType') && isRecord(value.sourceConfig);
+}
+function isAutomationCondition(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind === 'always')
+        return true;
+    if (value.kind === 'expression')
+        return hasString(value, 'expression');
+    return value.kind === 'approved-script' && hasString(value, 'scriptId') && hasString(value, 'approvedVersionId') && value.edge === 'rising';
+}
+function isAutomationAction(value) {
+    return isRecord(value) && value.kind === 'agent-prompt' && hasString(value, 'promptTemplate') &&
+        (value.executionMode === 'same-thread' || value.executionMode === 'side-thread');
+}
+function isAutomationDelivery(value) {
+    return isRecord(value) && hasString(value, 'platform') && isChannelRoute(value.route);
+}
+function isAutomationPolicies(value) {
+    return isRecord(value) && value.concurrency === 'skip-if-running' && isNonNegativeInteger(value.cooldownMs);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function isNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
 function isInstalledAgentRuntime(value) {
     return isRecord(value) &&
         hasString(value, 'agentType') &&
@@ -206,6 +299,14 @@ function isLocalCoreEvent(value) {
             return isAutomationMonitor(value.monitor);
         case 'automation.monitor.run.updated':
             return isAutomationMonitorRun(value.run);
+        case 'automation.definition.updated':
+            return isAutomationDefinition(value.automation);
+        case 'automation.evaluation.updated':
+            return isAutomationEvaluation(value.evaluation);
+        case 'automation.run.updated':
+            return isAutomationRun(value.run);
+        case 'automation.script-version.updated':
+            return isAutomationScriptVersion(value.version);
         case 'presence.updated':
             return hasBoolean(value, 'live') && (value.stream === undefined || isDesktopBridgeEvent(value.stream));
         case 'stream.updated':

package/dist-electron/packages/core-sdk/src/index.js

@@ -36,11 +36,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.knowledge = exports.automation = exports.scheduler = exports.channels = exports.threads = exports.runtime = void 0;
+exports.knowledge = exports.automations = exports.automation = exports.scheduler = exports.channels = exports.threads = exports.runtime = void 0;
 __exportStar(require("./client.js"), exports);
 exports.runtime = __importStar(require("./runtime.js"));
 exports.threads = __importStar(require("./threads.js"));
 exports.channels = __importStar(require("./channels.js"));
 exports.scheduler = __importStar(require("./scheduler.js"));
 exports.automation = __importStar(require("./automation.js"));
+exports.automations = __importStar(require("./automations.js"));
 exports.knowledge = __importStar(require("./knowledge.js"));