@quadient/skillshare 1.10.0 → 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
@@ -59,7 +61,8 @@ segment are sent to Skillshare.
 Starting with 1.7.0, `skillshare teams login` opens a dedicated local browser profile,
 connects your own Teams account to Skillshare and verifies the connection. Sign in with
 the same Microsoft account as Skillshare. The server refreshes captured tokens in the
-background. `teams watch` renews an expired Microsoft grant through local browser SSO.
+background. `teams watch` renews an expired Microsoft grant through local browser SSO; `agents listen` does the same
+while it runs, so a computer that runs agents needs no separate `teams watch` (`--no-teams-watch` turns it off).
 Keep that process running for automatic recovery beyond the SPA refresh token lifetime;
 another interactive CLI login is needed only when SSO cannot complete, for example MFA.
 

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,11 +10,26 @@ 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);
     const servers = start.mcpServers ?? [];
-    const args = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--include-partial-messages',
+    // Replayed user messages tell when Claude Code took a message, which is how a steered message is known to have joined the turn.
+    const args = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--include-partial-messages', '--replay-user-messages',
         ...(sandbox
             // A sandboxed session never prompts: anything outside the read-only allowlist is denied.
             ? ['--permission-mode', 'dontAsk', '--allowedTools', ...CLAUDE_SANDBOX_TOOLS, ...servers.map((server, index) => `mcp__${mcpServerName(server, index)}`)]
@@ -80,6 +96,12 @@ class ClaudeDriver {
     blocks = new Map();
     streamed = new Map();
     messageId = '';
+    /** Messages written to Claude Code whose replay has not come back yet, in order. */
+    echoes = [];
+    /** Steered messages Claude Code will run as their own turn; turn() then only waits for their outcome. */
+    submitted = new Set();
+    /** Outcomes of such turns that ended before turn() asked for them. */
+    early = [];
     costSoFar = 0;
     closing = false;
     constructor(context, options) {
@@ -114,16 +136,55 @@ class ClaudeDriver {
     }
     turn(message) {
         return new Promise((resolve, reject) => {
+            if (this.submitted.delete(message.id)) {
+                const early = this.early.shift();
+                if (early)
+                    resolve(early);
+                else
+                    this.current = { resolve, interrupted: false };
+                return;
+            }
             this.current = { resolve, interrupted: false };
-            const sent = this.process?.write(JSON.stringify({
-                type: 'user', message: { role: 'user', content: message.text }, parent_tool_use_id: null, session_id: this.sessionId ?? '',
-            }));
-            if (!sent) {
+            if (!this.write(message)) {
                 this.current = null;
                 reject(new Error('Claude Code is not accepting input.'));
             }
         });
     }
+    /**
+     * Claude Code takes a message written during a turn at its next tool boundary. If the turn ends first, the message starts
+     * a turn of its own; its replay arriving before or after the turn's result tells which happened.
+     */
+    steer(message) {
+        if (!this.current)
+            return Promise.resolve('notSent');
+        return new Promise(resolve => {
+            if (!this.write(message, outcome => {
+                if (outcome === 'steered')
+                    this.submitted.delete(message.id);
+                resolve(outcome);
+            }))
+                return resolve('notSent');
+            this.submitted.add(message.id);
+        });
+    }
+    write(message, steered) {
+        const sent = this.process?.write(JSON.stringify({
+            type: 'user', message: { role: 'user', content: claudeContent(message) }, parent_tool_use_id: null, session_id: this.sessionId ?? '',
+        }));
+        if (sent)
+            this.echoes.push({ text: message.text, steered });
+        return Boolean(sent);
+    }
+    replayed(content) {
+        const text = typeof content === 'string' ? content
+            : Array.isArray(content) ? content.map((block) => typeof block?.text === 'string' ? block.text : '').join('') : '';
+        const index = this.echoes.findIndex(echo => echo.text === text);
+        if (index < 0)
+            return;
+        const [echo] = this.echoes.splice(index, 1);
+        echo.steered?.(this.current ? 'steered' : 'nextTurn');
+    }
     async interrupt() {
         if (!this.current)
             return;
@@ -191,7 +252,7 @@ class ClaudeDriver {
             case 'assistant':
                 return this.assistant(frame.message ?? {});
             case 'user':
-                return this.toolResults(frame.message?.content);
+                return frame.isReplay === true ? this.replayed(frame.message?.content) : this.toolResults(frame.message?.content);
             case 'result':
                 return this.result(frame);
         }
@@ -242,8 +303,7 @@ class ClaudeDriver {
             this.adopt(frame.session_id);
         const current = this.current;
         this.current = null;
-        if (!current)
-            return;
+        const record = (outcome) => current ? current.resolve(outcome) : this.early.push(outcome);
         // Costs are totals for the process; a turn's share is the difference.
         const cost = typeof frame.total_cost_usd === 'number' ? frame.total_cost_usd : undefined;
         const turnCost = cost === undefined ? undefined : Math.max(0, cost - this.costSoFar);
@@ -251,21 +311,24 @@ class ClaudeDriver {
             this.costSoFar = cost;
         const usage = frame.usage ?? {};
         const input = [usage.input_tokens, usage.cache_creation_input_tokens, usage.cache_read_input_tokens].filter((n) => typeof n === 'number');
+        const count = (value) => typeof value === 'number' ? value : undefined;
         const stats = { costUsd: turnCost, inputTokens: input.length > 0 ? input.reduce((a, b) => a + b, 0) : undefined,
-            outputTokens: typeof usage.output_tokens === 'number' ? usage.output_tokens : undefined };
+            cachedInputTokens: count(usage.cache_read_input_tokens), cacheWriteTokens: count(usage.cache_creation_input_tokens), outputTokens: count(usage.output_tokens) };
         if (frame.subtype === 'success' && frame.is_error !== true)
-            return current.resolve({ status: 'completed', stats });
-        if (current.interrupted)
-            return current.resolve({ status: 'interrupted', stats });
+            return record({ status: 'completed', stats });
+        if (current?.interrupted)
+            return record({ status: 'interrupted', stats });
         const detail = typeof frame.result === 'string' && frame.result ? frame.result
             : Array.isArray(frame.errors) && frame.errors.length > 0 ? frame.errors.join(' ') : `Claude Code ended the turn with ${frame.subtype ?? 'an error'}.`;
-        current.resolve({ status: 'failed', error: clip(detail, 2000), stats });
+        record({ status: 'failed', error: clip(detail, 2000), stats });
     }
     onExit(code) {
         const reason = `Claude Code exited${code === null ? '' : ` with code ${code}`}${this.process?.stderrTail() ? `: ${this.process.stderrTail()}` : '.'}`;
         for (const waiter of this.controls.values())
             waiter.reject(new Error(reason));
         this.controls.clear();
+        for (const echo of this.echoes.splice(0))
+            echo.steered?.('notSent');
         this.current?.resolve({ status: 'failed', error: reason });
         this.current = null;
         if (!this.closing)

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);
@@ -126,9 +133,9 @@ class CodexDriver {
     turn(message) {
         const { configuration } = this.context.start;
         return new Promise((resolve, reject) => {
-            this.current = { resolve, usage: { input: 0, output: 0 } };
+            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')
@@ -143,6 +150,19 @@ class CodexDriver {
         if (this.current?.id && this.threadId)
             await this.request('turn/interrupt', { threadId: this.threadId, turnId: this.current.id });
     }
+    /** turn/steer adds input to the active turn; Codex refuses it once that turn is over, and the message then runs as the next turn. */
+    async steer(message) {
+        const turnId = this.current?.id;
+        if (!turnId || !this.threadId)
+            return 'notSent';
+        try {
+            await this.request('turn/steer', { threadId: this.threadId, expectedTurnId: turnId, input: codexInput(message) });
+            return 'steered';
+        }
+        catch {
+            return 'notSent';
+        }
+    }
     async close() {
         this.closing = true;
         await this.process?.kill();
@@ -234,6 +254,8 @@ class CodexDriver {
                 const last = params.tokenUsage?.last;
                 if (last && this.current) {
                     this.current.usage.input += Number(last.inputTokens) || 0;
+                    this.current.usage.cached += Number(last.cachedInputTokens) || 0;
+                    this.current.usage.cacheWrite += Number(last.cacheWriteInputTokens) || 0;
                     this.current.usage.output += Number(last.outputTokens) || 0;
                 }
                 return;
@@ -255,7 +277,8 @@ class CodexDriver {
                     return;
                 this.current = null;
                 const status = turn.status === 'completed' ? 'completed' : turn.status === 'interrupted' ? 'interrupted' : 'failed';
-                const stats = { inputTokens: current.usage.input, outputTokens: current.usage.output };
+                const { usage } = current;
+                const stats = { inputTokens: usage.input, cachedInputTokens: usage.cached, cacheWriteTokens: usage.cacheWrite, outputTokens: usage.output };
                 current.resolve(status === 'failed'
                     ? { status, error: codexErrorText(turn.error?.message) ?? current.error ?? 'The turn failed.', stats }
                     : { status, stats });

package/dist/agents-detect.js

@@ -2,6 +2,7 @@ import { execFile } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, isAbsolute, join, resolve } from 'node:path';
+import { startAgentProcess } from './agents-process.js';
 /** Model aliases Claude Code resolves to the latest release; Claude Code itself has no command that lists models. */
 export const CLAUDE_MODELS = ['fable', 'opus', 'sonnet', 'haiku'];
 export const CLAUDE_EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
@@ -30,19 +31,11 @@ export async function detectAgents(options = {}) {
     if (codexVersion !== null) {
         const codexHome = env.CODEX_HOME ?? join(home, '.codex');
         const warnings = [];
-        const cache = parseJson(await read(join(codexHome, 'models_cache.json')));
-        const models = Array.isArray(cache?.models) ? cache.models
-            .filter((m) => m?.visibility === 'list' && typeof m.slug === 'string' && NAME.test(m.slug))
-            .map((m) => {
-            const levels = (Array.isArray(m.supported_reasoning_levels) ? m.supported_reasoning_levels : [])
-                .map((level) => typeof level === 'string' ? level : level?.effort)
-                .filter((level) => typeof level === 'string' && NAME.test(level) && level !== 'default');
-            const fallback = typeof m.default_reasoning_level === 'string' && levels.includes(m.default_reasoning_level) ? m.default_reasoning_level : undefined;
-            return { id: m.slug, displayName: typeof m.display_name === 'string' ? m.display_name.slice(0, 100) : undefined,
-                reasoningLevels: levels.slice(0, 16), defaultReasoning: fallback };
-        }).slice(0, 64) : [];
+        // Codex's own model/list reflects the account; its cache file is the fallback when the app-server cannot be asked.
+        const listed = await (options.codexModels ?? (() => codexModelList()))().catch(() => null);
+        const models = listed ?? cachedCodexModels(parseJson(await read(join(codexHome, 'models_cache.json'))));
         if (models.length === 0)
-            warnings.push('No Codex model list found in models_cache.json. Run codex once to refresh it; only the default model is offered.');
+            warnings.push('Codex did not list its models. Run codex once to sign in or refresh it; only the default model is offered.');
         const configured = defaultCodexModel(await read(join(codexHome, 'config.toml')));
         if (configured && models.length > 0 && !models.some(m => m.id === configured))
             warnings.push(`The default model "${configured}" from config.toml is not in the Codex model list and may be rejected; pick a model explicitly.`);
@@ -59,6 +52,74 @@ export async function detectAgents(options = {}) {
         problems,
     };
 }
+/** Keeps the list within what the server accepts: valid names, no "default", and bounded sizes. */
+function codexModel(id, displayName, levels, fallback) {
+    if (typeof id !== 'string' || !NAME.test(id) || id === 'default')
+        return null;
+    const reasoningLevels = levels.filter((level) => typeof level === 'string' && NAME.test(level) && level !== 'default').slice(0, 16);
+    return { id, displayName: typeof displayName === 'string' ? displayName.slice(0, 100) : undefined, reasoningLevels,
+        defaultReasoning: typeof fallback === 'string' && reasoningLevels.includes(fallback) ? fallback : undefined };
+}
+/** Models from model/list of `codex app-server`, the same list the Codex UI offers; hidden models are left out. */
+export function codexModelsFromList(data) {
+    return (Array.isArray(data) ? data : []).filter((m) => m && m.hidden !== true)
+        .map((m) => codexModel(m.id ?? m.model, m.displayName, (Array.isArray(m.supportedReasoningEfforts) ? m.supportedReasoningEfforts : []).map((e) => e?.reasoningEffort), m.defaultReasoningEffort))
+        .filter((m) => m !== null).slice(0, 64);
+}
+function cachedCodexModels(cache) {
+    return (Array.isArray(cache?.models) ? cache.models : []).filter((m) => m?.visibility === 'list')
+        .map((m) => codexModel(m.slug, m.display_name, (Array.isArray(m.supported_reasoning_levels) ? m.supported_reasoning_levels : []).map((level) => typeof level === 'string' ? level : level?.effort), m.default_reasoning_level))
+        .filter((m) => m !== null).slice(0, 64);
+}
+/** Asks a short-lived `codex app-server` for model/list, following pages, and gives up after the timeout. */
+export async function codexModelList(options = {}) {
+    const pending = new Map();
+    let nextId = 0;
+    const agent = startAgentProcess({
+        command: options.command ?? 'codex', args: ['app-server'], cwd: homedir(), env: {}, spawnAgent: options.spawnAgent,
+        onLine: line => {
+            try {
+                const message = JSON.parse(line);
+                if (message.id !== undefined && message.method === undefined)
+                    pending.get(message.id)?.(message);
+            }
+            catch { }
+        },
+    });
+    const request = (method, params) => new Promise((resolvePromise, reject) => {
+        const id = ++nextId;
+        pending.set(id, message => message.error ? reject(new Error(String(message.error.message))) : resolvePromise(message.result ?? {}));
+        if (!agent.write(JSON.stringify({ id, method, params })))
+            reject(new Error('Codex is not accepting input.'));
+    });
+    const ask = async () => {
+        await request('initialize', { clientInfo: { name: 'skillshare', title: 'Skillshare', version: '0.0.0' }, capabilities: { experimentalApi: true } });
+        agent.write(JSON.stringify({ method: 'initialized' }));
+        const data = [];
+        let cursor;
+        for (let page = 0; page < 10; page++) {
+            const result = await request('model/list', cursor ? { cursor } : {});
+            data.push(...(Array.isArray(result.data) ? result.data : []));
+            cursor = typeof result.nextCursor === 'string' && result.nextCursor ? result.nextCursor : undefined;
+            if (!cursor)
+                break;
+        }
+        return codexModelsFromList(data);
+    };
+    let timer;
+    try {
+        const models = await Promise.race([ask(), agent.exited.then(() => null),
+            new Promise(resolvePromise => { timer = setTimeout(() => resolvePromise(null), options.timeoutMs ?? 20_000); })]);
+        return models && models.length > 0 ? models : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+        await agent.kill();
+    }
+}
 export function parseProfiles(text, home, problems = []) {
     if (text === null)
         return [];

package/dist/agents-session.js

@@ -104,6 +104,7 @@ export class SessionRunner {
     driver;
     seen = new Set();
     pending = [];
+    steering = new Set();
     now;
     opened = null;
     openSucceeded = false;
@@ -134,16 +135,43 @@ export class SessionRunner {
         });
     }
     get stopping() { return this.closing !== null; }
-    /** Queues messages for the next turns; the server may send a message again, so repeats are ignored. */
+    /**
+     * Queues messages for the next turns, or steers them into the running turn; the server may send a message again, so
+     * repeats are ignored.
+     */
     send(messages) {
         for (const message of messages) {
             if (this.seen.has(message.id))
                 continue;
             this.seen.add(message.id);
-            this.pending.push(message);
+            if (message.steer && this.turnRunning && this.openSucceeded && this.driver.steer)
+                this.steer(message);
+            else
+                this.pending.push(message);
         }
         void this.pump();
     }
+    /** A message that misses the running turn becomes the next one, ahead of anything queued after it. */
+    steer(message) {
+        const task = (async () => {
+            let outcome = 'notSent';
+            try {
+                outcome = await this.driver.steer(message);
+            }
+            catch { }
+            if (this.closing)
+                return;
+            if (outcome === 'steered')
+                this.events.push({ type: 'steered', messageId: message.id });
+            else
+                this.pending.unshift(message);
+        })();
+        this.steering.add(task);
+        void task.finally(() => {
+            this.steering.delete(task);
+            void this.pump();
+        });
+    }
     async interrupt() {
         if (!this.turnRunning || this.interruptRequested)
             return;
@@ -160,7 +188,8 @@ export class SessionRunner {
         return this.finish();
     }
     async pump() {
-        if (this.turnRunning || this.closing)
+        // While a steer is still being placed it decides what runs next; it pumps again once it knows.
+        if (this.turnRunning || this.closing || this.steering.size > 0)
             return;
         const message = this.pending.shift();
         if (!message) {

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);
@@ -44,7 +79,7 @@ export async function loadListenerId(appDirectory, baseUrl, userId) {
     await writeFile(file, JSON.stringify({ id }, null, 2), { mode: 0o600 });
     return id;
 }
-export async function runAgentsCommand(client, args, flags, appDirectory) {
+export async function runAgentsCommand(client, args, flags, appDirectory, teamsWatch) {
     const action = args[0];
     if (action === 'status') {
         const detected = await detectAgents();
@@ -74,10 +109,17 @@ export async function runAgentsCommand(client, args, flags, appDirectory) {
         ? 'Sandboxed: agents may read files, search and use the Skillshare MCP tools, but cannot change files or run commands that modify anything.'
         : 'Agents run with your full local permissions and configuration, without permission prompts. Use --sandbox to keep them read-only.');
     console.log('Sessions keep their agent running between messages and close it after 15 quiet minutes; the next message resumes it.');
+    // Teams 👀 sessions need a live Teams session, so the listener keeps it renewed unless told not to.
+    const teams = teamsWatch && flags['no-teams-watch'] !== 'true'
+        ? teamsWatch(abort.signal, message => console.log(`[teams] ${message}`))
+            .catch(error => console.log(`[teams] Teams renewal stopped: ${error instanceof Error ? error.message : String(error)}`))
+        : Promise.resolve();
     try {
         await listen({ client, listenerId, name: flags.name, workdir, maxConcurrency: max, sandbox, signal: abort.signal, onProgress: console.log });
     }
     finally {
+        abort.abort();
+        await teams;
         process.removeListener('SIGINT', stop);
         process.removeListener('SIGTERM', stop);
     }
@@ -110,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();
@@ -155,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/dist/help.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 export const GLOBAL_FLAGS = ['token', 'server', 'help'];
-export const BOOLEAN_FLAGS = new Set(['dry-run', 'force', 'headless', 'help', 'json', 'sandbox']);
+export const BOOLEAN_FLAGS = new Set(['dry-run', 'force', 'headless', 'help', 'json', 'no-teams-watch', 'sandbox']);
 export const COMMANDS = [
     {
         name: 'login',
@@ -110,14 +110,14 @@ export const COMMANDS = [
     },
     {
         name: 'agents',
-        summary: 'Run Claude Code or Codex tasks from Skillshare on this computer',
+        summary: 'Run Claude Code or Codex sessions from Skillshare on this computer',
         usage: [
-            'agents listen [local] [--name <name>] [--workdir <directory>] [--max-concurrency <1-4>] [--sandbox]',
+            'agents listen [local] [--name <name>] [--workdir <directory>] [--max-concurrency <1-4>] [--sandbox] [--no-teams-watch]',
             'agents status [local] [--json]',
         ],
-        description: 'A listener reports the installed agents, their models and reasoning levels, and the local profiles from ~/.config/skillshare/agents.json. It runs Claude Code and Codex sessions that you start and continue under Sessions in Skillshare; under Connected agents you choose which listener and configuration runs Teams 👀 sessions. Agents use your own login and run with your full local permissions, without permission prompts, unless --sandbox (or "sandbox": true in a profile) keeps them read-only. An idle agent is stopped after 15 minutes and resumed by the next message.',
+        description: 'A listener reports the installed agents, their models and reasoning levels, and the local profiles from ~/.config/skillshare/agents.json. It runs Claude Code and Codex sessions that you start and continue under Sessions in Skillshare; under Connected agents you choose which listener and configuration runs Teams 👀 sessions. Agents use your own login and run with your full local permissions, without permission prompts, unless --sandbox (or "sandbox": true in a profile) keeps them read-only. An idle agent is stopped after 15 minutes and resumed by the next message. With a Teams connection, the listener also keeps the Teams session renewed through local browser SSO, as skillshare teams watch does; --no-teams-watch turns that off.',
         examples: ['skillshare agents status', 'skillshare agents listen --workdir ~/Research'],
-        flags: ['name', 'workdir', 'max-concurrency', 'sandbox', 'json'],
+        flags: ['name', 'workdir', 'max-concurrency', 'sandbox', 'no-teams-watch', 'browser', 'headless', 'browser-profile', 'json'],
     },
     {
         name: 'git',

package/dist/index.js

@@ -1,4 +1,4 @@
-import { assertCredentialDestination, resolveTeamsObjectId, runTeamsCommand } from './teams.js';
+import { assertCredentialDestination, resolveTeamsObjectId, runTeamsCommand, watchTeamsInBackground } from './teams.js';
 import { runAgentsCommand } from './agents.js';
 import { formatUnknownCommand, parseCliArgs } from './cli-args.js';
 import { findCommand, readCliVersion, renderCommandHelp, renderUsage } from './help.js';
@@ -149,7 +149,8 @@ async function main() {
             assertCredentialDestination(baseUrl);
             if (!options.token && !await loadSession(baseUrl))
                 await login(baseUrl);
-            await runAgentsCommand(await createClient(baseUrl, options.token), options.positionals, options.flags, APP_DIR);
+            const agentsClient = await createClient(baseUrl, options.token);
+            await runAgentsCommand(agentsClient, options.positionals, options.flags, APP_DIR, (signal, log) => watchTeamsInBackground(agentsClient, options.flags, APP_DIR, signal, log));
             return;
         }
         case 'git': {

package/dist/teams.js

@@ -29,6 +29,44 @@ async function expectOk(response) {
     catch { }
     throw new Error(error.error ?? `Skillshare Teams API returned HTTP ${response.status}.`);
 }
+/**
+ * Captures a Teams session from the local browser profile and imports it. A watcher renews headless with a deadline and,
+ * given the connection it saw, imports conditionally, so a disconnect or another login in the meantime is not overwritten.
+ */
+function teamsConnector(client, flags, appDirectory, user, objectId, watching, signal, log) {
+    const key = createHash('sha256').update(client.baseUrl + '\0' + user.id).digest('hex').slice(0, 24);
+    const profileDirectory = flags['browser-profile'] ? resolve(flags['browser-profile']) : join(appDirectory, 'teams', key, 'browser-profile');
+    return async (connectionId) => {
+        const session = await captureTeamsLogin({ profileDirectory, objectId, browser: flags.browser,
+            headless: watching ? flags.headless !== 'false' : flags.headless === 'true', recover: watching,
+            signal, timeoutMs: watching ? 90_000 : undefined, onProgress: log });
+        const headers = { 'Content-Type': 'application/json' };
+        if (connectionId)
+            headers['If-Match'] = `"${connectionId}"`;
+        const response = await client.request(`${root}/session`, { method: 'PUT', headers, body: JSON.stringify(session), signal });
+        await expectOk(response);
+        await client.post(`${root}/test`);
+    };
+}
+/**
+ * Keeps an existing Teams connection renewed while another command runs, exactly like `teams watch`. Returns at once when
+ * the account has no Teams connection, so commands can always start it.
+ */
+export async function watchTeamsInBackground(client, flags, appDirectory, signal, log) {
+    assertCredentialDestination(client.baseUrl);
+    const status = await client.get(`${root}/settings`).catch(() => null);
+    if (!status?.connectionId)
+        return;
+    const user = await client.get('/api/auth/me');
+    const objectId = resolveTeamsObjectId(user);
+    if (!objectId) {
+        log(UNLINKED_ACCOUNT_MESSAGE);
+        return;
+    }
+    log('Keeping your Teams session renewed through local browser SSO, as skillshare teams watch does. Use --no-teams-watch to turn this off.');
+    await watchTeamsConnection({ readStatus: () => client.get(`${root}/settings`),
+        reconnect: teamsConnector(client, flags, appDirectory, user, objectId, true, signal, log), signal, onProgress: log });
+}
 export async function runTeamsCommand(client, args, flags, appDirectory) {
     // Browser credentials may be uploaded only over HTTPS, with HTTP reserved for loopback development.
     assertCredentialDestination(client.baseUrl);
@@ -38,21 +76,8 @@ export async function runTeamsCommand(client, args, flags, appDirectory) {
         const resolvedObjectId = resolveTeamsObjectId(user);
         if (!resolvedObjectId)
             throw new Error(UNLINKED_ACCOUNT_MESSAGE);
-        const objectId = resolvedObjectId;
-        const key = createHash('sha256').update(client.baseUrl + '\0' + user.id).digest('hex').slice(0, 24);
-        const profileDirectory = flags['browser-profile'] ? resolve(flags['browser-profile']) : join(appDirectory, 'teams', key, 'browser-profile');
         const abort = new AbortController();
-        async function connect(connectionId) {
-            const session = await captureTeamsLogin({ profileDirectory, objectId, browser: flags.browser,
-                headless: action === 'watch' ? flags.headless !== 'false' : flags.headless === 'true', recover: action === 'watch',
-                signal: abort.signal, timeoutMs: action === 'watch' ? 90_000 : undefined, onProgress: console.log });
-            const headers = { 'Content-Type': 'application/json' };
-            if (connectionId)
-                headers['If-Match'] = `"${connectionId}"`;
-            const response = await client.request(`${root}/session`, { method: 'PUT', headers, body: JSON.stringify(session), signal: abort.signal });
-            await expectOk(response);
-            await client.post(`${root}/test`);
-        }
+        const connect = teamsConnector(client, flags, appDirectory, user, resolvedObjectId, action === 'watch', abort.signal, console.log);
         if (action === 'login') {
             await connect();
             console.log(`Teams connected. Skillshare refreshes tokens automatically. Use skillshare teams watch for renewed browser SSO after session expiry.`);

package/package.json

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