alaska-ai 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# alaska-ai
+
+`alaska-ai` is a Node.js CLI package that starts the AI bridge service.
+
+## Install
+
+```bash
+npm install -g alaska-ai
+```
+
+## Usage
+
+```bash
+alaska-ai start
+```
+
+On first start, the setup wizard runs and requires a sandbox root directory (`projects_root`).
+All project directories must stay under that root.
+
+or run without global install:
+
+```bash
+npx alaska-ai start
+```
+
+Available commands:
+
+- `alaska-ai start` start the bridge (default command)
+- `alaska-ai configure` open settings menu
+- `alaska-ai init` run setup wizard
+- `alaska-ai --help` show help
+
+## Development
+
+```bash
+npm install
+npm run build
+node dist/cli.js --help
+npm start
+```
+
+Database setup for fresh deployments:
+
+```bash
+# Apply base schema first, then sandbox hardening constraints
+psql "$SUPABASE_DB_URL" -f supabase/schema.sql
+psql "$SUPABASE_DB_URL" -f supabase/init_sandbox.sql
+```
+
+## Publish to npm
+
+```bash
+npm login
+npm run prepublishOnly
+npm publish --access public
+```

package/dist/adapters/slack.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Slack adapter for Alaska.
+ *
+ * Connects to Slack via Socket Mode using @slack/bolt.
+ * Listens for messages and slash commands, routes them through the router,
+ * and posts responses back to the appropriate threads.
+ */
+import { App } from '@slack/bolt';
+import type { Router } from '../router.js';
+import type { Store } from '../store.js';
+export interface SlackAdapterOptions {
+    botToken: string;
+    appToken: string;
+    router: Router;
+    store: Store;
+    /** Optional pre-created App instance (for testing). */
+    app?: App;
+}
+export declare function createBoltApp(botToken: string, appToken: string): App;
+export declare class SlackAdapter {
+    private app;
+    private router;
+    private store;
+    private botUserId;
+    /** Message refs for pending AskUserQuestion prompts, for updating on resolution. */
+    private questionMessages;
+    /** Message refs for todo checklist messages, keyed by threadId (one per thread). */
+    private todoMessages;
+    /** Tracked permission/question ack messages per thread, for :eyes: cleanup after backend responds. */
+    private permissionAckMessages;
+    constructor(options: SlackAdapterOptions);
+    /** Start the Slack adapter - connects via Socket Mode. */
+    start(): Promise<void>;
+    /** Stop the Slack adapter - disconnect. */
+    stop(): Promise<void>;
+    /** Get the underlying Bolt app (for testing). */
+    getApp(): App;
+    /** Register all Slack event handlers. */
+    private registerHandlers;
+    /**
+     * Auto-join a channel if the bot isn't already in it.
+     * Returns true if the bot is in the channel, false if it can't join.
+     */
+    private ensureInChannel;
+    /** React with :eyes: to acknowledge a user's message. */
+    private reactSeen;
+    /** Remove the :eyes: reaction after the backend has responded. */
+    private removeReactSeen;
+    /** Swap :eyes: to checkmarkto confirm a schedule was created (no text reply needed). */
+    private reactScheduleConfirm;
+    /** Track a permission/question ack message for later :eyes: cleanup. */
+    private trackPermissionAck;
+    /** Remove :eyes: from all tracked permission ack messages for a thread. */
+    private cleanupPermissionAcks;
+    /** Handle an incoming Slack message. */
+    private handleMessage;
+    /** Handle freeform text when session is waiting_for_input. */
+    private handleFreeformResponse;
+    /** Handle permission Allow/Deny/Always Allow button clicks.
+     *  Button value is "toolName|requestId" (hook flow) or "toolName" (legacy). */
+    private handlePermissionAction;
+    /** Render normalized events as Slack messages in a thread. */
+    private renderEvents;
+    /** Post text response, splitting if it exceeds Slack's limit. */
+    postText(channelId: string, threadTs: string, text: string, client: any): Promise<void>;
+    /** Post a permission denial prompt with Allow/Deny buttons.
+     *  When event.requestId is set (hook-based flow), it's embedded in button values
+     *  so the action handler can resolve the permission in-process. */
+    postPermissionPrompt(channelId: string, threadTs: string, event: {
+        toolName: string;
+        toolInput: Record<string, unknown>;
+        context?: string;
+        requestId?: string;
+    }, client: any): Promise<void>;
+    /** Post an interactive question with dynamic option buttons.
+     *  Renders the first question from AskUserQuestion as Slack blocks with buttons. */
+    postUserQuestion(channelId: string, threadTs: string, questions: Array<{
+        question: string;
+        header: string;
+        options: Array<{
+            label: string;
+            description: string;
+        }>;
+        multiSelect: boolean;
+    }>, requestId: string, client: any): Promise<void>;
+    /** Handle AskUserQuestion option button clicks.
+     *  Resolves the pending question via IPC and updates the message. */
+    private handleQuestionAnswer;
+    /** Post an error message. */
+    postError(channelId: string, threadTs: string, message: string, client: any): Promise<void>;
+    /** Build the list of /project subcommand descriptions. */
+    private getProjectCommandLines;
+    /** Handle /project slash command. */
+    private handleProjectCommand;
+    /** Handle project connect flow - bind a directory to a channel. */
+    private handleProjectConnect;
+    /** Post a project picker with pagination support. */
+    private postProjectPicker;
+    /** Get the default backend, or throw if not configured. */
+    private getDefaultBackend;
+    /** Handle permission mode button action. */
+    private handlePermModeAction;
+    /** Post a sandbox denial notice (no upgrade path). */
+    private postSandboxDeniedNotice;
+    /** Post permission mode selection prompt after project creation. */
+    private postPermissionModePrompt;
+    /** Bind a project to a channel and post confirmation. */
+    private bindProjectToChannel;
+    /** Create a new Slack channel, bind a project to it, and invite the user. */
+    private createChannelAndBind;
+    /** Handle name_taken error when creating a channel - offer to bind existing. */
+    private handleNameTaken;
+    /** Handle /settings slash command. */
+    private handleSettingsCommand;
+    /** Handle file uploads in messages - downloads all file types for backend passthrough. */
+    handleFileUpload(channelId: string, threadTs: string, files: any[], text: string, client: any, messageTs?: string): Promise<void>;
+    /** Upload a file to a Slack thread. Called by MCP callback handler. */
+    uploadFile(channelId: string, threadId: string, filePath: string): Promise<void>;
+    /** Post a plain text message to a Slack thread. Called by MCP callback handler. */
+    sendMessage(channelId: string, threadId: string, text: string): Promise<void>;
+    createThread(channelId: string, title: string): Promise<string>;
+    /** Format todos as Slack mrkdwn checklist. */
+    private formatTodosSlack;
+    renderTodoList(channelId: string, threadId: string, todos: Array<{
+        content: string;
+        status: string;
+        activeForm: string;
+    }>): Promise<void>;
+}
+export { splitText } from '../utils.js';