@quadient/skillshare 1.10.1 → 1.10.2

package/README.md

@@ -30,7 +30,9 @@ without permission prompts.
 
 Codex runs as `codex app-server` and Claude Code with stream-json input and output. The agent
 keeps running between your messages and stops after 15 quiet minutes; the next message resumes
-the same Codex thread or Claude Code session. Sessions need CLI 1.10.0 or newer.
+the same Codex thread or Claude Code session. Sessions need CLI 1.10.0 or newer. Images
+attached to messages reach the agent from CLI 1.10.2: the listener downloads them to a temp
+directory that it removes when the session closes.
 
 ```sh
 skillshare agents status

package/dist/agents-claude.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -9,6 +10,20 @@ import { CLAUDE_SANDBOX_TOOLS, DEFAULT, SANDBOX_NOTE, clip, isSandboxed, mcpServ
  * user's own claude install, so their login and settings apply. MCP config and the session's instructions are passed per
  * process; tokens only through the environment.
  */
+/** Plain text, or with images the content blocks of the message: its text, then each downloaded image inline as base64. */
+export function claudeContent(message) {
+    const images = (message.images ?? []).flatMap(image => {
+        try {
+            return [{ type: 'image', source: { type: 'base64', media_type: image.mediaType, data: readFileSync(image.path).toString('base64') } }];
+        }
+        catch {
+            return [];
+        }
+    });
+    if (images.length === 0)
+        return message.text;
+    return [...(message.text ? [{ type: 'text', text: message.text }] : []), ...images];
+}
 export function claudeArgs(context, mcpConfigPath) {
     const { start } = context;
     const sandbox = isSandboxed(start.configuration, context);
@@ -130,7 +145,7 @@ class ClaudeDriver {
                 return;
             }
             this.current = { resolve, interrupted: false };
-            if (!this.write(message.text)) {
+            if (!this.write(message)) {
                 this.current = null;
                 reject(new Error('Claude Code is not accepting input.'));
             }
@@ -144,7 +159,7 @@ class ClaudeDriver {
         if (!this.current)
             return Promise.resolve('notSent');
         return new Promise(resolve => {
-            if (!this.write(message.text, outcome => {
+            if (!this.write(message, outcome => {
                 if (outcome === 'steered')
                     this.submitted.delete(message.id);
                 resolve(outcome);
@@ -153,12 +168,12 @@ class ClaudeDriver {
             this.submitted.add(message.id);
         });
     }
-    write(text, steered) {
+    write(message, steered) {
         const sent = this.process?.write(JSON.stringify({
-            type: 'user', message: { role: 'user', content: text }, parent_tool_use_id: null, session_id: this.sessionId ?? '',
+            type: 'user', message: { role: 'user', content: claudeContent(message) }, parent_tool_use_id: null, session_id: this.sessionId ?? '',
         }));
         if (sent)
-            this.echoes.push({ text, steered });
+            this.echoes.push({ text: message.text, steered });
         return Boolean(sent);
     }
     replayed(content) {

package/dist/agents-codex.js

@@ -13,6 +13,13 @@ export function codexConfigArgs(args) {
     return kept;
 }
 /** thread/start and thread/resume share these: where to work, what may run, the session's MCP servers and instructions. */
+/** The message as Codex user input: its text, then each downloaded image as a local file Codex reads itself. */
+export function codexInput(message) {
+    return [
+        ...(message.text ? [{ type: 'text', text: message.text }] : []),
+        ...(message.images ?? []).filter(image => image.path).map(image => ({ type: 'localImage', path: image.path })),
+    ];
+}
 export function codexThreadParams(context) {
     const { start } = context;
     const sandbox = isSandboxed(start.configuration, context);
@@ -128,7 +135,7 @@ class CodexDriver {
         return new Promise((resolve, reject) => {
             this.current = { resolve, usage: { input: 0, cached: 0, cacheWrite: 0, output: 0 } };
             this.request('turn/start', {
-                threadId: this.threadId, input: [{ type: 'text', text: message.text }],
+                threadId: this.threadId, input: codexInput(message),
                 ...(configuration.reasoning !== DEFAULT ? { effort: configuration.reasoning } : {}),
             }).then(result => {
                 if (this.current && typeof result?.turn?.id === 'string')
@@ -149,7 +156,7 @@ class CodexDriver {
         if (!turnId || !this.threadId)
             return 'notSent';
         try {
-            await this.request('turn/steer', { threadId: this.threadId, expectedTurnId: turnId, input: [{ type: 'text', text: message.text }] });
+            await this.request('turn/steer', { threadId: this.threadId, expectedTurnId: turnId, input: codexInput(message) });
             return 'steered';
         }
         catch {

package/dist/agents.js

@@ -1,12 +1,12 @@
 import { createHash, randomBytes } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { hostname, platform } from 'node:os';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { hostname, platform, tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { createClaudeDriver } from './agents-claude.js';
 import { createCodexDriver } from './agents-codex.js';
 import { detectAgents, profilesPath } from './agents-detect.js';
-import { SessionRunner } from './agents-session.js';
+import { SessionRunner, errorMessage, } from './agents-session.js';
 import { readCliVersion } from './help.js';
 const root = '/api/agents';
 const PROFILE_HINT = 'Declare named profiles in ' + profilesPath() + ' to set a working directory or extra arguments.';
@@ -29,6 +29,41 @@ async function send(client, method, path, body, signal) {
     }
     return response.status === 204 ? undefined : await response.json();
 }
+const MAX_IMAGE_BYTES = 6 * 1024 * 1024;
+const IMAGE_ID = /^[0-9a-f]{32}\.(png|jpg|gif|webp)$/;
+/**
+ * Downloads the images of each message into the session's directory, so the agent reads them as local files. An image that
+ * cannot be fetched is left out and the agent is told, so the turn still runs.
+ */
+export async function downloadImages(client, directory, messages) {
+    return Promise.all(messages.map(async (message) => {
+        if (!message.images?.length)
+            return message;
+        const images = [];
+        const problems = [];
+        for (const image of message.images) {
+            try {
+                if (!IMAGE_ID.test(image.id) || !image.url.startsWith(`${root}/sessions/`))
+                    throw new Error('unexpected image link');
+                const response = await client.request(image.url, { method: 'GET' });
+                if (!response.ok)
+                    throw new Error(`HTTP ${response.status}`);
+                const data = Buffer.from(await response.arrayBuffer());
+                if (data.length > MAX_IMAGE_BYTES)
+                    throw new Error('the image is too large');
+                await mkdir(directory, { recursive: true });
+                const path = join(directory, image.id);
+                await writeFile(path, data);
+                images.push({ ...image, path });
+            }
+            catch (error) {
+                problems.push(errorMessage(error));
+            }
+        }
+        const note = problems.length ? `\n\n[${problems.length} attached image(s) could not be downloaded from Skillshare: ${problems.join('; ')}]` : '';
+        return { ...message, text: (message.text + note).trim(), images };
+    }));
+}
 /** One stable listener id per Skillshare server and account, so the web keeps routes across restarts. */
 export async function loadListenerId(appDirectory, baseUrl, userId) {
     const key = createHash('sha256').update(baseUrl + '\0' + userId).digest('hex').slice(0, 24);
@@ -117,6 +152,9 @@ export async function listen(options) {
     const now = options.now ?? Date.now;
     const log = options.onProgress ?? (() => { });
     const sessions = new Map();
+    // Messages reach a session in order even while earlier ones still download their images.
+    const deliveries = new Map();
+    const imageRoot = options.imageDirectory ?? join(tmpdir(), 'skillshare-agents');
     let detected = await detect();
     let registeredFingerprint = '';
     let detectedAt = now();
@@ -162,18 +200,32 @@ export async function listen(options) {
         });
         sessions.set(command.sessionId, runner);
         log(`${command.start.resumeThreadId ? 'Resumed' : 'Started'} session ${command.sessionId} "${command.start.title}" with ${label(command.start)}.`);
-        void runner.done.then(() => {
-            if (sessions.get(command.sessionId) === runner)
+        void runner.done.then(async () => {
+            if (sessions.get(command.sessionId) === runner) {
                 sessions.delete(command.sessionId);
+                deliveries.delete(command.sessionId);
+                await rm(join(imageRoot, command.sessionId), { recursive: true, force: true }).catch(() => { });
+            }
             log(`Closed session ${command.sessionId}.`);
         });
-        runner.send(command.messages ?? []);
+        deliver(runner, command.messages ?? []);
+    }
+    function deliver(runner, messages) {
+        if (messages.length === 0)
+            return;
+        if (!messages.some(message => message.images?.length) && !deliveries.has(runner.sessionId))
+            return runner.send(messages);
+        const previous = deliveries.get(runner.sessionId) ?? Promise.resolve();
+        const next = previous.then(() => downloadImages(options.client, join(imageRoot, runner.sessionId), messages)).then(ready => runner.send(ready));
+        deliveries.set(runner.sessionId, next);
+        void next.finally(() => { if (deliveries.get(runner.sessionId) === next)
+            deliveries.delete(runner.sessionId); });
     }
     function handle(command) {
         const runner = sessions.get(command.sessionId);
         switch (command.type) {
             case 'start': return start(command);
-            case 'send': return runner?.send(command.messages ?? []);
+            case 'send': return runner && deliver(runner, command.messages ?? []);
             case 'interrupt': return void runner?.interrupt();
             case 'close': return void runner?.close();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quadient/skillshare",
-  "version": "1.10.1",
+  "version": "1.10.2",
   "description": "Skillshare CLI for installing and publishing Quadient skills",
   "type": "module",
   "bin": {