@meetquinn/animactl 0.1.1-canary.21.1.cd63d38

package/dist/server/agents/agent-slack.service.js

@@ -0,0 +1,198 @@
+import { CURRENT_SLACK_MANIFEST_VERSION, } from '../../shared/slack-manifest.js';
+import { AgentConfigError } from './agent-config-ops.js';
+import { AgentService } from './agent.service.js';
+import { appIdFromAppToken, getBotTokenScopes, getSlackDisplayInfo, validateSlackTokenPair, } from './agent-slack-validation.js';
+import { nowIso } from '../ids.js';
+import { WakeQueueService } from '../inbox/wake-queue.service.js';
+import { slackAppInstallUrl, slackAppManifestUrl, slackAppManifestYaml, } from '../slack/app-manifest.js';
+import { createSlackWebClient } from '../slack/client.js';
+import { hasCommandsScope, } from '../slack/shortcuts.js';
+import { SlackWorkspaceDirectoryService } from '../slack/workspace-directory.service.js';
+export class AgentSlackService {
+    agentService;
+    constructor(agentService) {
+        this.agentService = agentService;
+    }
+    // Per-agent Slack workflows. Lower-level Slack details stay private here.
+    async validateTokens(input) {
+        return validateSlackTokenPair(input);
+    }
+    async connect(input) {
+        const validation = await validateSlackTokenPair(input);
+        if (!validation.connection.valid) {
+            throw new AgentConfigError(400, 'Slack token validation failed');
+        }
+        const connection = validation.connection;
+        const hasCurrentManifest = hasCommandsScope(await getBotTokenScopes(input.botToken).catch(() => []));
+        const current = await this.agentService.getConfig();
+        return this.agentService.saveConfig({
+            ...current,
+            slack: {
+                ...current.slack,
+                appId: connection.appId || '',
+                appToken: input.appToken,
+                avatarUrl: connection.botAvatarUrl || '',
+                botToken: input.botToken,
+                manifestVersion: hasCurrentManifest ? CURRENT_SLACK_MANIFEST_VERSION : 0,
+                teamId: connection.teamId || '',
+                workspaceIconUrl: connection.workspaceIconUrl || '',
+                workspaceName: connection.workspaceName || '',
+            },
+        });
+    }
+    async getManifestUpdateInfo() {
+        const agent = await this.agentService.getConfig();
+        const appId = agent.slack.appId || appIdFromAppToken(agent.slack.appToken);
+        const agentVersion = agent.slack.manifestVersion ?? 0;
+        return {
+            agentVersion,
+            ...(appId ? {
+                appManifestUrl: slackAppManifestUrl(appId, agent.slack.teamId),
+                reinstallUrl: slackAppInstallUrl(appId),
+            } : {}),
+            currentVersion: CURRENT_SLACK_MANIFEST_VERSION,
+            manifestUpdateYaml: await slackAppManifestYaml(agent),
+            needsUpdate: agentVersion < CURRENT_SLACK_MANIFEST_VERSION,
+        };
+    }
+    async upgradeManifestVersion(input) {
+        const agent = await this.agentService.getConfig();
+        if (!agent.slack.appToken) {
+            throw new AgentConfigError(400, `Agent ${agent.id} has no app token configured`);
+        }
+        const validation = await validateSlackTokenPair({
+            appToken: agent.slack.appToken,
+            botToken: input.botToken,
+        });
+        if (!validation.connection.valid) {
+            throw new AgentConfigError(400, 'Slack token validation failed');
+        }
+        const scopes = await getBotTokenScopes(input.botToken);
+        if (!hasCommandsScope(scopes)) {
+            throw new AgentConfigError(400, 'New bot token is missing the commands scope. Update the Slack app manifest, reinstall the app, then paste the new Bot User OAuth Token.');
+        }
+        const connection = validation.connection;
+        return this.agentService.saveConfig({
+            ...agent,
+            slack: {
+                ...agent.slack,
+                appId: connection.appId || agent.slack.appId || '',
+                avatarUrl: connection.botAvatarUrl || '',
+                botToken: input.botToken,
+                manifestVersion: CURRENT_SLACK_MANIFEST_VERSION,
+                teamId: connection.teamId || '',
+                workspaceIconUrl: connection.workspaceIconUrl || '',
+                workspaceName: connection.workspaceName || '',
+            },
+        });
+    }
+    async syncDisplayInfo() {
+        const agent = await this.agentService.getConfig();
+        const info = await getSlackDisplayInfo(await this.getWebClient());
+        const appId = info.appId ?? appIdFromAppToken(agent.slack.appToken);
+        return this.agentService.saveConfig({
+            ...agent,
+            slack: {
+                ...agent.slack,
+                ...info,
+                ...(appId ? { appId } : {}),
+            },
+        });
+    }
+    async getWebClient() {
+        return (await this.getAgentWebClient()).client;
+    }
+    async getAgentWebClient() {
+        const agent = await this.agentService.getConfig();
+        return { agent, client: this.webClientForAgent(agent) };
+    }
+    webClientForAgent(agent) {
+        return createSlackWebClient(requireBotToken(agent));
+    }
+    async fetchPrivateUrl(url) {
+        const agent = await this.agentService.getConfig();
+        return fetch(url, { headers: { Authorization: `Bearer ${requireBotToken(agent)}` } });
+    }
+    async listUsers() {
+        const { agent, client } = await this.getAgentWebClient();
+        return new SlackWorkspaceDirectoryService({ client, teamId: agent.slack.teamId }).getUserCandidates();
+    }
+    async setOwner(input) {
+        const agent = await this.agentService.getConfig();
+        const client = this.webClientForAgent(agent);
+        const candidates = await new SlackWorkspaceDirectoryService({ client, teamId: agent.slack.teamId }).getUserCandidates();
+        const owner = candidates.find((user) => user.slackUserId === input.slackUserId);
+        if (!owner)
+            throw new AgentConfigError(400, `Slack user not found: ${input.slackUserId}`);
+        const introduce = input.introduce !== false; // default true
+        const onboardingPromptedAt = introduce
+            ? await this.ensureOwnerOnboardingPrompt(agent, owner, input.openerNote)
+            : (agent.owner?.slackUserId === owner.slackUserId ? agent.owner.onboardingPromptedAt : undefined);
+        return this.agentService.saveConfig({
+            ...agent,
+            owner: { ...owner, ...(onboardingPromptedAt ? { onboardingPromptedAt } : {}) },
+        });
+    }
+    async getInstallUrl() {
+        const agent = await this.agentService.getConfig();
+        const manifestYaml = await slackAppManifestYaml(agent);
+        return `https://api.slack.com/apps?new_app=1&manifest_yaml=${encodeURIComponent(manifestYaml)}`;
+    }
+    async ensureOwnerOnboardingPrompt(agent, owner, openerNote) {
+        const existingPromptedAt = agent.owner?.slackUserId === owner.slackUserId ? agent.owner.onboardingPromptedAt : undefined;
+        if (existingPromptedAt)
+            return existingPromptedAt;
+        const client = await this.getWebClient();
+        const auth = await client.auth.test();
+        if (!auth.team_id)
+            throw new AgentConfigError(502, 'Slack auth.test did not return a team id');
+        const dm = await new SlackWorkspaceDirectoryService({ client, teamId: auth.team_id }).openDm(owner.slackUserId);
+        if (!dm.id)
+            throw new AgentConfigError(502, `Slack did not return a DM channel for ${owner.slackUserId}`);
+        const mention = `<@${owner.slackUserId}>`;
+        const ownerName = owner.displayName?.trim()
+            || operatorHandleLabel(owner.handle)
+            || mention;
+        const now = nowIso();
+        const textLines = [
+            ownerName === mention
+                ? `You've been set up here. Your owner is ${mention}.`
+                : `You've been set up here. Your owner is ${ownerName} (${mention}).`,
+        ];
+        if (openerNote?.trim()) {
+            textLines.push(`Context from whoever set you up (might be ${ownerName}, might be someone else): ${openerNote.trim()}`);
+            textLines.push(`Treat this as their intent, not fact — confirm with ${ownerName} what they actually need.`);
+        }
+        textLines.push(`Start by reading your MEMORY.md — its Onboarding section walks you through getting set up — then reply here to introduce yourself to ${ownerName}.`);
+        await new WakeQueueService(agent.id).enqueue({
+            channelId: dm.id,
+            handling: { createdAt: now, queuedAt: now, status: 'queued', updatedAt: now },
+            id: `agent-onboarding:${agent.id}:${owner.slackUserId}`,
+            kind: 'onboarding',
+            operator: {
+                displayName: owner.displayName,
+                ...(owner.handle ? { handle: owner.handle } : {}),
+                slackUserId: owner.slackUserId,
+            },
+            receivedAt: now,
+            teamId: auth.team_id,
+            text: textLines.join('\n'),
+        });
+        return now;
+    }
+}
+export function agentSlackServiceForAgent(agentId) {
+    return new AgentSlackService(new AgentService(agentId));
+}
+function requireBotToken(agent) {
+    const token = agent.slack.botToken;
+    if (!token)
+        throw new AgentConfigError(400, `Agent ${agent.id} has no bot token configured`);
+    return token;
+}
+function operatorHandleLabel(handle) {
+    const trimmed = handle?.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.startsWith('@') ? trimmed : `@${trimmed}`;
+}

package/dist/server/agents/agent.service.d.ts

@@ -0,0 +1,41 @@
+import { type AgentConfig, type AgentCreateRequest, type AgentUpdateProfileRequest, type AgentUpdateProviderRequest } from '../../shared/agent-config.js';
+import type { AgentSkills } from '../../shared/skills.js';
+import { AgentRegistryStore, AgentStore } from '../storage/schema/agent.store.js';
+import { type KbRegistryService } from '../kb/kb.service.js';
+import { SessionStore, type ArchivedProviderSession, type Session } from '../storage/schema/session.store.js';
+export { AgentConfigError } from './agent-config-ops.js';
+export interface RotateSessionResult {
+    agentId: string;
+    archivedAt: string;
+    archivedProviderSessions: ArchivedProviderSession[];
+}
+export declare class AgentService {
+    private readonly agentId;
+    private readonly store;
+    private readonly sessionStore;
+    constructor(agentId: string, store?: AgentStore, sessionStore?: SessionStore);
+    exists(): boolean;
+    getConfig(): Promise<AgentConfig>;
+    createAgent(agent: AgentConfig): Promise<AgentConfig>;
+    setEnabled(enabled: boolean): Promise<AgentConfig>;
+    updateHome(homePath: string): Promise<AgentConfig>;
+    updateProfile(profile: AgentUpdateProfileRequest): Promise<AgentConfig>;
+    updateProvider(provider: AgentUpdateProviderRequest): Promise<AgentConfig>;
+    getSession(): Promise<Session | null>;
+    getSkills(): Promise<AgentSkills>;
+    rotateSession(note?: string): Promise<RotateSessionResult>;
+    removeAgent(): Promise<AgentConfig>;
+    saveConfig(agent: AgentConfig): Promise<AgentConfig>;
+    private archiveCurrentProviderSession;
+}
+export declare class AgentRegistryService {
+    private readonly registry;
+    private readonly kbRegistryService;
+    constructor(registry?: AgentRegistryStore, kbRegistryService?: KbRegistryService);
+    listAgentConfigs(): Promise<AgentConfig[]>;
+    listAgentIds(): Promise<string[]>;
+    createAgent(input: AgentCreateRequest): Promise<AgentConfig>;
+    serviceFor(agentId: string): AgentService;
+}
+export declare const defaultAgentRegistryService: AgentRegistryService;
+//# sourceMappingURL=agent.service.d.ts.map

package/dist/server/agents/agent.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.service.d.ts","sourceRoot":"","sources":["../../../server/agents/agent.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAChC,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAa1D,OAAO,EACL,kBAAkB,EAClB,UAAU,EACX,MAAM,kCAAkC,CAAC;AAK1C,OAAO,EAA4B,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EACL,YAAY,EACZ,KAAK,uBAAuB,EAC5B,KAAK,OAAO,EACb,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,wBAAwB,EAAE,uBAAuB,EAAE,CAAC;CACrD;AAWD,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAFZ,OAAO,EAAE,MAAM,EACf,KAAK,GAAE,UAAoC,EAC3C,YAAY,GAAE,YAAwC;IAGzE,MAAM,IAAI,OAAO;IAIX,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC;IAQjC,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAOrD,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC;IAIlD,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAKlD,aAAa,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,WAAW,CAAC;IAKvE,cAAc,CAAC,QAAQ,EAAE,0BAA0B,GAAG,OAAO,CAAC,WAAW,CAAC;IAW1E,UAAU,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAIrC,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC;IAIjC,aAAa,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAM1D,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAMnC,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;YAO5C,6BAA6B;CAkC5C;AAED,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;gBADjB,QAAQ,GAAE,kBAA6C,EACvD,iBAAiB,GAAE,iBAA4C;IAG5E,gBAAgB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAKhD,YAAY,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAI3B,WAAW,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC;IAclE,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY;CAG1C;AAED,eAAO,MAAM,2BAA2B,sBAA6B,CAAC"}

package/dist/server/agents/agent.service.js

@@ -0,0 +1,149 @@
+import { AgentConfigError, agentConfigWithProviderUpdate, agentConfigFromCreateInput, assertAgentConfigId, ensureCreateAgentHome, ensureExistingAgentHome, normalizeAgentConfig, validateAgentConfig, } from './agent-config-ops.js';
+import { scanAgentSkills } from './agent-skills.js';
+import { activityServiceForAgent } from '../activities/activity.service.js';
+import { AgentRegistryStore, AgentStore, } from '../storage/schema/agent.store.js';
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { nowIso } from '../ids.js';
+import { writeSeedMemory } from './seed-memory.js';
+import { defaultKbRegistryService } from '../kb/kb.service.js';
+import { SessionStore, } from '../storage/schema/session.store.js';
+export { AgentConfigError } from './agent-config-ops.js';
+// ---------------------------------------------------------------------------
+// AgentService
+// ---------------------------------------------------------------------------
+export class AgentService {
+    agentId;
+    store;
+    sessionStore;
+    constructor(agentId, store = new AgentStore(agentId), sessionStore = new SessionStore(agentId)) {
+        this.agentId = agentId;
+        this.store = store;
+        this.sessionStore = sessionStore;
+    }
+    exists() {
+        return this.store.exists();
+    }
+    async getConfig() {
+        const path = this.store.path();
+        if (!this.store.exists())
+            throw new AgentConfigError(404, `Agent not found in config: ${this.agentId}`);
+        const agent = await this.store.read();
+        assertAgentConfigId(this.agentId, agent, path);
+        return agent;
+    }
+    async createAgent(agent) {
+        if (this.store.exists()) {
+            throw new AgentConfigError(409, `Agent already exists in config: ${this.agentId}`);
+        }
+        return this.saveConfig(agent);
+    }
+    async setEnabled(enabled) {
+        return this.saveConfig({ ...(await this.getConfig()), enabled });
+    }
+    async updateHome(homePath) {
+        await ensureExistingAgentHome(homePath);
+        return this.saveConfig({ ...(await this.getConfig()), homePath });
+    }
+    async updateProfile(profile) {
+        const current = await this.getConfig();
+        return this.saveConfig({ ...current, profile: { ...current.profile, ...profile } });
+    }
+    async updateProvider(provider) {
+        const current = await this.getConfig();
+        const next = await this.saveConfig(agentConfigWithProviderUpdate(current, provider));
+        if (provider.kind && provider.kind !== current.provider.kind) {
+            await this.archiveCurrentProviderSession(`provider switched from ${current.provider.kind} to ${next.provider.kind}`);
+        }
+        return next;
+    }
+    async getSession() {
+        return (await this.sessionStore.read()) ?? null;
+    }
+    async getSkills() {
+        return scanAgentSkills(await this.getConfig());
+    }
+    async rotateSession(note) {
+        const archived = await this.archiveCurrentProviderSession(note?.trim() || undefined);
+        if (!archived)
+            throw new AgentConfigError(409, `No active provider sessions for agent ${this.agentId}`);
+        return { agentId: this.agentId, ...archived };
+    }
+    async removeAgent() {
+        const agent = await this.getConfig();
+        await this.store.remove();
+        return agent;
+    }
+    async saveConfig(agent) {
+        const next = normalizeAgentConfig(this.agentId, agent);
+        await validateAgentConfig(next);
+        await this.store.write(next);
+        return this.getConfig();
+    }
+    async archiveCurrentProviderSession(note) {
+        const archivedAt = nowIso();
+        let updated;
+        let archived;
+        await this.sessionStore.update((session) => {
+            if (!session?.current)
+                return undefined;
+            archived = {
+                ...session.current,
+                archivedAt,
+                archivedBy: 'operator',
+                ...(note ? { note } : {}),
+            };
+            const { current: _current, latestProviderStats: _latestProviderStats, ...rest } = session;
+            updated = {
+                ...rest,
+                archived: dedupeArchivedSessions([archived, ...(session.archived ?? [])]),
+                currentStartedAt: archivedAt,
+                updatedAt: archivedAt,
+            };
+            return updated;
+        });
+        if (!updated || !archived)
+            return undefined;
+        const archivedProviderSessions = [archived];
+        await activityServiceForAgent(this.agentId).record({
+            type: 'anima.session.rotate',
+            payload: { archivedAt, archivedCount: 1, archivedProviderSessions, ...(note ? { note } : {}) },
+        });
+        return { archivedAt, archivedProviderSessions };
+    }
+}
+export class AgentRegistryService {
+    registry;
+    kbRegistryService;
+    constructor(registry = new AgentRegistryStore(), kbRegistryService = defaultKbRegistryService) {
+        this.registry = registry;
+        this.kbRegistryService = kbRegistryService;
+    }
+    async listAgentConfigs() {
+        const ids = await this.registry.listIds();
+        return Promise.all(ids.map((id) => this.serviceFor(id).getConfig()));
+    }
+    listAgentIds() {
+        return this.registry.listIds();
+    }
+    async createAgent(input) {
+        const agent = agentConfigFromCreateInput(input);
+        const service = this.serviceFor(agent.id);
+        if (service.exists()) {
+            throw new AgentConfigError(409, `Agent already exists in config: ${agent.id}`);
+        }
+        await ensureCreateAgentHome(agent.homePath);
+        await this.kbRegistryService.ensureDefaultTeamKbForAgentHome(agent.homePath);
+        const created = await service.createAgent(agent);
+        await writeSeedMemory(created);
+        await mkdir(join(created.homePath, 'notes'), { recursive: true });
+        return created;
+    }
+    serviceFor(agentId) {
+        return new AgentService(agentId);
+    }
+}
+export const defaultAgentRegistryService = new AgentRegistryService();
+function dedupeArchivedSessions(sessions) {
+    return [...new Map(sessions.map((s) => [`${s.kind}:${s.id}`, s])).values()];
+}

package/dist/server/agents/seed-memory.d.ts

@@ -0,0 +1,4 @@
+import type { AgentConfig } from '../../shared/agent-config.js';
+export declare function writeSeedMemory(agent: AgentConfig): Promise<void>;
+export declare function renderSeedMemory(agent: Pick<AgentConfig, 'id' | 'profile'>): Promise<string>;
+//# sourceMappingURL=seed-memory.d.ts.map

package/dist/server/agents/seed-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-memory.d.ts","sourceRoot":"","sources":["../../../server/agents/seed-memory.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAQhE,wBAAsB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAUvE;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,SAAS,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAIlG"}

package/dist/server/agents/seed-memory.js

@@ -0,0 +1,26 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readBundledTemplate } from '../bundled-templates.js';
+import { isMissingFile } from '../storage/json-file.js';
+// Template file: templates/agent-seed-memory.md
+// Keep it generic — no team-specific content; operating mechanics live in the standing prompt.
+const TEMPLATE_FILE = 'agent-seed-memory.md';
+export async function writeSeedMemory(agent) {
+    if (!agent.homePath)
+        throw new Error(`Agent ${agent.id}: homePath is required`);
+    const memoryPath = join(agent.homePath, 'MEMORY.md');
+    try {
+        await readFile(memoryPath, 'utf8');
+        return;
+    }
+    catch (error) {
+        if (!isMissingFile(error))
+            throw error;
+    }
+    await writeFile(memoryPath, await renderSeedMemory(agent), 'utf8');
+}
+export async function renderSeedMemory(agent) {
+    const template = await readBundledTemplate(TEMPLATE_FILE);
+    const displayName = agent.profile?.displayName?.trim() || agent.id;
+    return template.replaceAll('{{displayName}}', displayName);
+}

package/dist/server/anima-home.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveAnimaHome(): string;
+export declare function withAnimaHome<T>(dir: string, body: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=anima-home.d.ts.map

package/dist/server/anima-home.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anima-home.d.ts","sourceRoot":"","sources":["../../server/anima-home.ts"],"names":[],"mappings":"AAOA,wBAAgB,gBAAgB,IAAI,MAAM,CAQzC;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEhF"}

package/dist/server/anima-home.js

@@ -0,0 +1,28 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+const animaHomeScope = new AsyncLocalStorage();
+export function resolveAnimaHome() {
+    const scopedHome = animaHomeScope.getStore();
+    if (scopedHome)
+        return scopedHome;
+    const envHome = process.env.ANIMA_HOME?.trim();
+    if (envHome)
+        return resolve(envHome);
+    const local = resolve('.anima');
+    if (isDirectory(local))
+        return local;
+    return join(homedir(), '.anima');
+}
+export function withAnimaHome(dir, body) {
+    return animaHomeScope.run(resolve(dir), body);
+}
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/server/asks/interactive-ask.service.d.ts

@@ -0,0 +1,54 @@
+import type { WebClient } from '@slack/web-api';
+import type { AgentOwner } from '../../shared/agent-config.js';
+import type { ChoiceResponseInboxItem } from '../../shared/inbox.js';
+import { type ActivityService } from '../activities/activity.service.js';
+import { WakeQueueService } from '../inbox/wake-queue.service.js';
+import { type SlackUserInfo } from '../slack/workspace-directory.service.js';
+import { InteractiveAskStore, type InteractiveAskOption, type InteractiveAskRecord } from '../storage/schema/interactive-ask.store.js';
+export declare const INTERACTIVE_ASK_ACTION_ID = "anima.ask.answer";
+export interface InteractiveAskAnswerInput {
+    askId: string;
+    client: WebClient;
+    optionId: string;
+    userId: string;
+}
+export interface InteractiveAskAnswerResult {
+    ask?: InteractiveAskRecord;
+    outcome: 'answered' | 'already_answered' | 'forbidden' | 'not_found' | 'invalid_option';
+    queued?: boolean;
+}
+export declare class InteractiveAskService {
+    private readonly store;
+    private readonly queue;
+    private readonly activity;
+    constructor(agentId: string, store?: InteractiveAskStore, queue?: WakeQueueService, activity?: ActivityService);
+    saveAsk(record: InteractiveAskRecord): Promise<InteractiveAskRecord>;
+    getAsk(askId: string): Promise<InteractiveAskRecord | undefined>;
+    answerAsk(input: InteractiveAskAnswerInput): Promise<InteractiveAskAnswerResult>;
+    replaceAnsweredMessage(input: {
+        ask: InteractiveAskRecord;
+        client: WebClient;
+    }): Promise<void>;
+    notifyForbiddenClick(input: {
+        ask: InteractiveAskRecord;
+        client: WebClient;
+        userId: string;
+    }): Promise<void>;
+    private canUserAnswer;
+    private answeringUser;
+    private recordAnswerActivity;
+    private pruneOldAnswered;
+}
+export declare function interactiveAskServiceForAgent(agentId: string): InteractiveAskService;
+export declare function choiceResponseInboxItem(ask: InteractiveAskRecord, option: InteractiveAskOption, answeredBy: NonNullable<InteractiveAskRecord['answeredBy']>): ChoiceResponseInboxItem;
+export declare function slackAnswerUser(user: SlackUserInfo | undefined, fallback: string): {
+    displayName?: string;
+    handle?: string;
+    slackUserId: string;
+};
+export declare function ownerAllowedUser(owner: AgentOwner): {
+    displayName?: string;
+    handle?: string;
+    slackUserId: string;
+};
+//# sourceMappingURL=interactive-ask.service.d.ts.map

package/dist/server/asks/interactive-ask.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactive-ask.service.d.ts","sourceRoot":"","sources":["../../../server/asks/interactive-ask.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAElG,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAkC,KAAK,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAC7G,OAAO,EACL,mBAAmB,EACnB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EAC1B,MAAM,4CAA4C,CAAC;AAEpD,eAAO,MAAM,yBAAyB,qBAAqB,CAAC;AAG5D,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC,GAAG,CAAC,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,UAAU,GAAG,kBAAkB,GAAG,WAAW,GAAG,WAAW,GAAG,gBAAgB,CAAC;IACxF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,qBAAa,qBAAqB;IAG9B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAHzB,OAAO,EAAE,MAAM,EACE,KAAK,GAAE,mBAAsD,EAC7D,KAAK,GAAE,gBAAgD,EACvD,QAAQ,GAAE,eAAkD;IAGzE,OAAO,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAMpE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;IAIhE,SAAS,CAAC,KAAK,EAAE,yBAAyB,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAqDhF,sBAAsB,CAAC,KAAK,EAAE;QAClC,GAAG,EAAE,oBAAoB,CAAC;QAC1B,MAAM,EAAE,SAAS,CAAC;KACnB,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBX,oBAAoB,CAAC,KAAK,EAAE;QAChC,GAAG,EAAE,oBAAoB,CAAC;QAC1B,MAAM,EAAE,SAAS,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;KAChB,GAAG,OAAO,CAAC,IAAI,CAAC;IAUjB,OAAO,CAAC,aAAa;YAIP,aAAa;YAYb,oBAAoB;YAmBpB,gBAAgB;CAQ/B;AAED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAEpF;AAED,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,oBAAoB,EACzB,MAAM,EAAE,oBAAoB,EAC5B,UAAU,EAAE,WAAW,CAAC,oBAAoB,CAAC,YAAY,CAAC,CAAC,GAC1D,uBAAuB,CAmBzB;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG;IAClF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB,CAaA;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB,CAMA"}