@sulala/agent 0.1.6 → 0.1.7

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@sulala/agent",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Local AI orchestration platform — file watcher, task scheduler, AI layer, plugins",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
     "start": "tsx src/index.ts",
+    "install-ollama": "node install-ollama.cjs",
     "gateway": "tsx src/gateway/server.ts",
     "dashboard": "cd dashboard && npm run dev",
     "dashboard:build": "cd dashboard && npm run build",
@@ -28,9 +29,18 @@
     "local"
   ],
   "license": "MIT",
-  "files": ["dist", "bin", "src/db/schema.sql", "registry", "context", "dashboard/dist"],
+  "files": [
+    "dist",
+    "bin",
+    "src/db/schema.sql",
+    "registry",
+    "context",
+    "dashboard/dist"
+  ],
   "prepublishOnly": "pnpm run build && pnpm run dashboard:build",
-  "publishConfig": { "access": "public" },
+  "publishConfig": {
+    "access": "public"
+  },
   "bin": {
     "sulala": "bin/sulala.mjs"
   },
@@ -40,10 +50,16 @@
     "cors": "^2.8.5",
     "dotenv": "^16.4.5",
     "express": "^4.21.1",
+    "grammy": "^1.40.1",
     "node-cron": "^3.0.3",
     "openai": "^6.25.0",
     "ws": "^8.18.0"
   },
+  "optionalDependencies": {
+    "@mariozechner/pi-agent-core": "0.54.0",
+    "@mariozechner/pi-ai": "0.54.0",
+    "@mariozechner/pi-coding-agent": "0.54.0"
+  },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/better-sqlite3": "^7.6.13",

package/registry/bluesky.md

@@ -1,111 +1,34 @@
 ---
 name: bluesky
-description: Post to Bluesky (AT Protocol). Use when the user asks to post a tweet/thread to Bluesky, share content on Bluesky, or post news/headlines from a source (URL or text) to Bluesky.
+description: Post to Bluesky (AT Protocol). Use when the user asks to post to Bluesky or share content on Bluesky. Uses Portal OAuth connection via integrations.
 homepage: https://bsky.app
 metadata:
   {
     "sulala": {
       "emoji": "🦋",
-      "requires": { "bins": ["curl", "python3", "sh"], "env": ["BSKY_HANDLE", "BSKY_APP_PASSWORD"] },
-      "primaryEnv": "BSKY_APP_PASSWORD"
+      "requires": { "bins": ["curl"] }
     }
   }
 ---
 
 # Bluesky Posting
 
-Post to Bluesky via the AT Protocol. Use **run_command** with `curl`, `python3`, and `sh`. Add `curl`, `python3`, and `sh` to ALLOWED_BINARIES.
+Post to Bluesky via the AT Protocol. Uses the **Portal OAuth connection** (integrations). User connects Bluesky in the Portal; no app password needed.
 
-Requires `BSKY_HANDLE` (e.g. `your.bsky.social`) and `BSKY_APP_PASSWORD` (app password from bsky.app → Settings → App Passwords). Set them in `.env` or in the skill config (`~/.sulala/config.json` or `.sulala/config.json` in the project; see Skill config in the dashboard). Config is re-read when the file changes; enable/disable takes effect without restart.
+## How to post
 
-**IMPORTANT:** `run_command` does not run a shell — `$BSKY_HANDLE` and `$BSKY_APP_PASSWORD` will not expand if you call curl directly. Always use `binary: "sh"` and `args: ["-c", "curl ... $BSKY_HANDLE ... $BSKY_APP_PASSWORD ..."]` so the env vars expand.
+1. **list_integrations_connections** with `provider: "bluesky"` → get `connection_id`.
+2. **bluesky_post** with that `connection_id` and the post text (max 300 characters).
 
-## When to Use
+Use **bluesky_post**; do not use run_command (curl) for Bluesky.
+
+## When to use
 
 - "Post this to Bluesky"
 - "Share [content] on Bluesky"
 - "Post news from [URL] to Bluesky"
-- "Post a headline about [topic]"
-
-## Post Flow (non-interactive)
-
-### 1. Ensure credentials
-
-```
-BSKY_HANDLE="${BSKY_HANDLE:?Set BSKY_HANDLE}"
-BSKY_APP_PASSWORD="${BSKY_APP_PASSWORD:?Set BSKY_APP_PASSWORD}"
-```
-
-If empty, read from Sulala config:
-
-```
-CONFIG_PATH="${SULALA_CONFIG_PATH:-$HOME/.sulala/config.json}"
-# If using workspace config, use: CONFIG_PATH=".sulala/config.json" (when run from project root)
-BSKY_HANDLE=$(cat "$CONFIG_PATH" 2>/dev/null | python3 -c "import sys,json; d=json.load(sys.stdin); e=d.get('skills',{}).get('entries',{}).get('bluesky',{}); print(e.get('handle','') or e.get('apiKey',''))" 2>/dev/null)
-BSKY_APP_PASSWORD=$(cat "$CONFIG_PATH" 2>/dev/null | python3 -c "import sys,json; d=json.load(sys.stdin); e=d.get('skills',{}).get('entries',{}).get('bluesky',{}); print(e.get('apiKey','') or e.get('password',''))" 2>/dev/null)
-```
-
-(Config may use `handle` + `apiKey` for Bluesky. Adjust field names if your config differs.)
-
-### 2. Create session (login)
-
-**Use `run_command` with `binary: "sh"` and `args: ["-c", "..."]`** so `$BSKY_HANDLE` and `$BSKY_APP_PASSWORD` expand from the environment. Do NOT call curl directly.
-
-```bash
-sh -c 'SESSION=$(curl -s -X POST "https://bsky.social/xrpc/com.atproto.server.createSession" -H "Content-Type: application/json" -d "{\"identifier\": \"$BSKY_HANDLE\", \"password\": \"$BSKY_APP_PASSWORD\"}"); echo "$SESSION"'
-```
-
-Then parse the JSON output with `python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('accessJwt',''), d.get('did',''))"` to get `ACCESS_TOKEN` and `DID`.
-
-If the session response contains `"error"` or `"AuthenticationRequired"`, report: "Bluesky login failed. Check BSKY_HANDLE and BSKY_APP_PASSWORD in .env."
-
-### 3. Create post
-
-Text must be JSON-escaped. Use python to build the payload. **Use `run_command` with `binary: "sh"`** so `$ACCESS_TOKEN`, `$DID`, and other vars expand.
-
-Run a single `sh -c` that chains steps 2 and 3 so SESSION, ACCESS_TOKEN, DID persist in the same shell:
-
-```bash
-sh -c '
-  SESSION=$(curl -s -X POST "https://bsky.social/xrpc/com.atproto.server.createSession" \
-    -H "Content-Type: application/json" \
-    -d "{\"identifier\": \"$BSKY_HANDLE\", \"password\": \"$BSKY_APP_PASSWORD\"}");
-  ACCESS_TOKEN=$(echo "$SESSION" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get(\"accessJwt\",\"\"))");
-  DID=$(echo "$SESSION" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get(\"did\",\"\"))");
-  if [ -z "$ACCESS_TOKEN" ]; then echo "Login failed"; exit 1; fi;
-  POST_TEXT="Your post content here";
-  POST_JSON=$(python3 -c "import sys,json; print(json.dumps(sys.argv[1]))" "$POST_TEXT");
-  NOW=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z");
-  curl -s -X POST "https://bsky.social/xrpc/com.atproto.repo.createRecord" \
-    -H "Authorization: Bearer $ACCESS_TOKEN" \
-    -H "Content-Type: application/json" \
-    -d "{\"repo\": \"$DID\", \"collection\": \"app.bsky.feed.post\", \"record\": {\"\\$type\": \"app.bsky.feed.post\", \"text\": $POST_JSON, \"createdAt\": \"$NOW\"}}"
-'
-```
-
-Replace `Your post content here` with the user's post text.
-
-If the response contains `"uri"`, the post succeeded. Otherwise report the error.
-
-## Posting from a news source
-
-When the user wants to post **news** or **content from a URL**:
-
-1. **Fetch the content** (e.g. with `curl -s <URL>` or read a file).
-2. **Summarize** if the content is long — Bluesky posts are max 300 characters. Write a short headline or summary.
-3. **Post** using the flow above. Optionally append the source URL if it fits within 300 chars.
-
-Example for "post news from https://example.com/article":
-- Fetch the page, extract title/lead.
-- Build post: "Headline here — https://example.com/article"
-- Post via the createRecord flow above.
-
-## Character limit
-
-Bluesky posts are limited to 300 characters. If the user's text or your summary exceeds that, truncate or split into multiple posts (thread). For a thread, create each post separately; the API does not natively support threads — you would need to reference the previous post's URI if linking them (advanced).
 
-## Notes
+## Requirements
 
-- Use an **app password**, not the main account password. Create at bsky.app → Settings → App Passwords.
-- `bsky.social` is the default PDS; custom PDS users would need a different host.
-- Do not embed real credentials in the skill or in replies — use env or config.
+- **PORTAL_GATEWAY_URL** and **PORTAL_API_KEY** (from Portal → API Keys).
+- User must have connected Bluesky in the Portal (Connections).

package/registry/skills-registry.json

@@ -35,6 +35,12 @@
       "name": "news",
       "description": "Fetch news and articles via the Perigon API. Use when the user asks for news, headlines, or articles on a topic.",
       "version": "1.0.0"
+    },
+    {
+      "slug": "portal-integrations",
+      "name": "portal-integrations",
+      "description": "Use connected apps (Gmail, Calendar, Zoom, Slack, GitHub, etc.) via the Portal. List connections with list_integrations_connections, then use connection_id in provider tools.",
+      "version": "1.0.0"
     }
   ]
 }

package/src/db/schema.sql

@@ -68,7 +68,42 @@ CREATE TABLE IF NOT EXISTS agent_messages (
 
 CREATE INDEX IF NOT EXISTS idx_agent_messages_session ON agent_messages(session_id);
 
+-- Agent memory: session-scoped and shared (cross-session) durable notes
+CREATE TABLE IF NOT EXISTS agent_memory (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  scope TEXT NOT NULL,
+  scope_key TEXT NOT NULL,
+  content TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_agent_memory_scope_key ON agent_memory(scope, scope_key);
+
 CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
 CREATE INDEX IF NOT EXISTS idx_tasks_scheduled ON tasks(scheduled_at);
 CREATE INDEX IF NOT EXISTS idx_logs_created ON logs(created_at);
 CREATE INDEX IF NOT EXISTS idx_ai_results_created ON ai_results(created_at);
+
+-- Channel config (Telegram, etc.) — set from dashboard
+CREATE TABLE IF NOT EXISTS channel_config (
+  channel TEXT PRIMARY KEY,
+  config TEXT NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+-- Scheduled jobs: legacy (task_type + payload) or agent jobs (prompt + delivery)
+CREATE TABLE IF NOT EXISTS scheduled_jobs (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL DEFAULT '',
+  description TEXT NOT NULL DEFAULT '',
+  cron_expression TEXT NOT NULL,
+  task_type TEXT NOT NULL DEFAULT 'agent_job',
+  payload TEXT,
+  prompt TEXT,
+  delivery TEXT,
+  provider TEXT,
+  model TEXT,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_scheduled_jobs_enabled ON scheduled_jobs(enabled);

package/src/index.ts

@@ -1,20 +1,100 @@
 import 'dotenv/config';
 import { createServer } from 'http';
+import {
+  getWatchFoldersFromAutomations,
+  runMatchingAutomations,
+} from './workspace-automations.js';
 import { loadFullConfig } from './agent/skills-config.js';
 import { config } from './config.js';
-import { initDb, log } from './db/index.js';
+import { initDb, log, getChannelConfig } from './db/index.js';
 import { createGateway, attachWebSocket } from './gateway/server.js';
 import { startWatcher, setEventCallback, enqueueTaskOnEvent } from './watcher/index.js';
 import { setTaskHandler, loadPendingFromDb, enqueue } from './scheduler/queue.js';
-import { scheduleCron } from './scheduler/cron.js';
+import { scheduleCronEphemeral, scheduleCronById } from './scheduler/cron.js';
+import { loadSchedulesConfig } from './config.js';
+import { listScheduledJobs } from './db/index.js';
 import { loadAllPlugins, onFileEvent, onTask } from './plugins/index.js';
 import { fireWebhooks } from './webhooks.js';
 import { registerBuiltInTools } from './agent/tools.js';
 import { startSkillsWatcher } from './agent/skills-watcher.js';
+import { ensureOllamaInstalled } from './ollama-setup.js';
+import { getOrCreateAgentSession } from './db/index.js';
+import { runAgentTurn } from './agent/loop.js';
+import { sendTelegramNotification, startTelegramChannel, resolveDefaultProviderAndModel } from './channels/telegram.js';
 import type { AppLocals } from './types.js';
 
+type DeliveryTarget = { channel: string; target?: string };
+
+const JOB_DEFAULT_CHANNEL_KEY = 'job_default';
+
+function parseJobDefaultConfig(raw: string | null): { defaultProvider?: string; defaultModel?: string } | null {
+  if (!raw?.trim()) return null;
+  try {
+    const o = JSON.parse(raw) as Record<string, unknown>;
+    const defaultProvider = typeof o.defaultProvider === 'string' ? o.defaultProvider.trim() || undefined : undefined;
+    const defaultModel = typeof o.defaultModel === 'string' ? o.defaultModel.trim() || undefined : undefined;
+    if (!defaultProvider && !defaultModel) return null;
+    return { defaultProvider, defaultModel };
+  } catch {
+    return null;
+  }
+}
+
+async function runAgentJobAndNotify(payload: unknown): Promise<void> {
+  const p = payload as { jobId?: string; name?: string; prompt?: string; delivery?: DeliveryTarget[]; provider?: string; model?: string } | null;
+  if (!p?.prompt?.trim()) {
+    log('worker', 'warn', 'agent_job missing prompt', { payload: p });
+    return;
+  }
+  const jobName = p.name?.trim() || p.jobId || 'Scheduled job';
+  const deliveryList = Array.isArray(p.delivery) ? p.delivery : [];
+  const sessionKey = `job_${p.jobId ?? 'run'}_${Date.now()}`;
+  const session = getOrCreateAgentSession(sessionKey);
+  const jobProvider = typeof p.provider === 'string' ? p.provider.trim() || undefined : undefined;
+  const jobModel = typeof p.model === 'string' ? p.model.trim() || undefined : undefined;
+  const jobDefaultFromDb = parseJobDefaultConfig(getChannelConfig(JOB_DEFAULT_CHANNEL_KEY));
+  const { provider, model } = resolveDefaultProviderAndModel({
+    provider: jobProvider ?? jobDefaultFromDb?.defaultProvider,
+    model: jobModel ?? jobDefaultFromDb?.defaultModel,
+  });
+
+  const sendNotification = async (text: string): Promise<void> => {
+    for (const d of deliveryList) {
+      if (d.channel === 'telegram') {
+        await sendTelegramNotification(text);
+      }
+    }
+  };
+
+  try {
+    const result = await runAgentTurn({
+      sessionId: session.id,
+      userMessage: p.prompt.trim(),
+      provider,
+      model,
+      skipToolApproval: true,
+    });
+    const summary = result.finalContent?.trim()?.slice(0, 2000) || '(No output)';
+    const message = `✅ Job «${jobName}» completed.\n\n${summary}`;
+    await sendNotification(message);
+    log('worker', 'info', `Agent job completed: ${jobName}`, { jobId: p.jobId });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    const message = `❌ Job «${jobName}» failed.\n\n${errorMsg.slice(0, 1500)}`;
+    await sendNotification(message);
+    log('worker', 'error', `Agent job failed: ${jobName}`, { jobId: p.jobId, error: errorMsg });
+    throw err;
+  }
+}
+
 async function main(): Promise<void> {
   initDb(config.dbPath);
+  if (process.env.SULALA_OLLAMA_AUTO_INSTALL === '1') {
+    ensureOllamaInstalled();
+  } else {
+    // Don't auto-install Ollama on startup; user must confirm via UI
+    console.log('[Ollama] Auto-install disabled. Install from Settings or ollama.com when needed.');
+  }
   // Inject skill config into process.env so run_command (e.g. curl with $PERIGON_API_KEY) sees them
   const full = loadFullConfig();
   const entries = full.skills?.entries;
@@ -27,6 +107,13 @@ async function main(): Promise<void> {
       }
     }
   }
+  // Merge allowedBinaries from config into ALLOWED_BINARIES (skills using curl, git, etc.)
+  const configBins = full.allowedBinaries;
+  if (Array.isArray(configBins) && configBins.length > 0) {
+    const envBins = (process.env.ALLOWED_BINARIES || '').split(',').map((b) => b.trim()).filter(Boolean);
+    const merged = [...new Set([...envBins, ...configBins.map((b) => String(b).trim().toLowerCase()).filter(Boolean)])];
+    process.env.ALLOWED_BINARIES = merged.join(',');
+  }
   log('main', 'info', 'Starting Sulala Agent', { port: config.port });
 
   registerBuiltInTools(enqueue);
@@ -58,21 +145,87 @@ async function main(): Promise<void> {
     broadcast({ type: 'file_event', payload });
     fireWebhooks('file_event', payload);
   });
-  startWatcher();
+  const automationFolders = getWatchFoldersFromAutomations();
+  const allWatchFolders = [...new Set([...config.watchFolders, ...automationFolders])];
+  startWatcher(allWatchFolders.length ? allWatchFolders : null);
   startSkillsWatcher(config, (ev) => broadcast(ev));
 
-  setTaskHandler(async (task) => {
+  const taskHandler = async (task: {
+    id: string;
+    type: string;
+    payload: unknown;
+    retry_count: number;
+    max_retries: number;
+  }) => {
     const handled = await onTask(task);
     if (handled) return;
+    if (task.type === 'agent_job') {
+      try {
+        await runAgentJobAndNotify(task.payload);
+      } catch {
+        // already logged and notified; rethrow so queue marks task failed
+        throw new Error('Agent job failed');
+      }
+      broadcast({ type: 'task_done', taskId: task.id });
+      fireWebhooks('task_done', { taskId: task.id, type: task.type });
+      return;
+    }
     if (task.type === 'file_event') {
+      const payload = task.payload as { event?: string; path?: string } | null;
       log('worker', 'info', 'File event task', (task.payload ?? null) as Record<string, unknown> | null);
+      if (payload?.event && payload?.path) {
+        runMatchingAutomations(payload.event, payload.path);
+      }
     }
     broadcast({ type: 'task_done', taskId: task.id });
     fireWebhooks('task_done', { taskId: task.id, type: task.type });
-  });
+  };
+  setTaskHandler(taskHandler);
 
   loadPendingFromDb();
-  scheduleCron('* * * * *', 'heartbeat', { ts: Date.now() });
+  // Heartbeat runs every minute; ephemeral = no DB row to avoid filling tasks table
+  scheduleCronEphemeral('* * * * *', 'heartbeat', () => ({ ts: Date.now() }), taskHandler);
+
+  // Config-driven schedules (config/schedules.json)
+  const configSchedules = loadSchedulesConfig();
+  configSchedules.forEach((entry, i) => {
+    try {
+      scheduleCronById(`config_${i}`, entry.cron, entry.type, entry.payload ?? null);
+      log('main', 'info', `Scheduled job from config: ${entry.type}`, { cron: entry.cron });
+    } catch (e) {
+      log('main', 'error', `Invalid schedule config at index ${i}: ${(e as Error).message}`, { cron: entry.cron, type: entry.type });
+    }
+  });
+
+  // DB-driven schedules (dashboard Jobs): agent jobs (prompt) or legacy (task_type + payload)
+  const dbSchedules = listScheduledJobs(true);
+  dbSchedules.forEach((row) => {
+    try {
+      if (row.prompt?.trim()) {
+        const delivery = row.delivery?.trim() ? JSON.parse(row.delivery) as DeliveryTarget[] : [];
+        const r = row as { provider?: string | null; model?: string | null };
+        const payload = {
+          jobId: row.id,
+          name: row.name || row.id,
+          prompt: row.prompt,
+          delivery,
+          provider: r.provider?.trim() || undefined,
+          model: r.model?.trim() || undefined,
+        };
+        scheduleCronById(row.id, row.cron_expression, 'agent_job', payload);
+        log('main', 'info', `Scheduled agent job from DB: ${row.name || row.id}`, { id: row.id });
+      } else {
+        const payload = row.payload ? JSON.parse(row.payload) : null;
+        scheduleCronById(row.id, row.cron_expression, row.task_type, payload);
+        log('main', 'info', `Scheduled job from DB: ${row.task_type}`, { id: row.id });
+      }
+    } catch (e) {
+      log('main', 'error', `Invalid scheduled job ${row.id}: ${(e as Error).message}`);
+    }
+  });
+
+  // Start Telegram bot if enabled and configured (so it stays connected without opening Settings)
+  startTelegramChannel();
 
   log('main', 'info', 'Sulala Agent ready');
 }