@quadient/skillshare 1.9.0 → 1.10.1

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. Choose which listener and configuration runs each kind of task under Connected agents in Skillshare. Agents run with your full local permissions, without permission prompts, unless --sandbox (or "sandbox": true in a profile) keeps them read-only.',
+        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.9.0",
+  "version": "1.10.1",
   "description": "Skillshare CLI for installing and publishing Quadient skills",
   "type": "module",
   "bin": {

package/dist/agents-run.js

@@ -1,174 +0,0 @@
-import { spawn } from 'node:child_process';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-const DEFAULT = 'default';
-/** Read-only tools Claude Code may use in a sandboxed run; MCP servers from the assignment are added per server. */
-export const CLAUDE_SANDBOX_TOOLS = ['Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'];
-export const SANDBOX_NOTE = '\n\nThis run is sandboxed: you can read files, search and use the provided MCP tools, but you cannot change files or run ' +
-    'commands that modify anything. Give your final answer as your last message; writing SKILLSHARE_AGENT_RESULT may not be possible.';
-/**
- * Builds the agent invocation. The prompt goes to stdin and tokens to environment variables, so neither
- * appears in the process list. Agents run without permission prompts, with the user's own configuration.
- */
-export function isSandboxed(assignment, options) {
-    return options.sandbox === true || options.profile?.sandbox === true || assignment.configuration.sandbox === true;
-}
-export function buildAgentCommand(assignment, options) {
-    const sandbox = isSandboxed(assignment, options);
-    const { configuration } = assignment;
-    const env = { SKILLSHARE_AGENT_RESULT: join(options.directory, 'result.md'), SKILLSHARE_TASK_ID: assignment.taskId };
-    const servers = assignment.mcpServers.map((server, index) => {
-        const variable = `SKILLSHARE_MCP_TOKEN_${index}`;
-        env[variable] = server.bearerToken;
-        return { name: server.name.replace(/[^A-Za-z0-9_-]/g, '_') || `server_${index}`, url: server.url, variable };
-    });
-    const cwd = options.profile?.workdir ?? options.workdir;
-    const extra = options.profile?.args ?? [];
-    if (configuration.agent === 'claude') {
-        // A sandboxed run never prompts: anything outside the read-only allowlist is denied.
-        const args = ['-p', '--output-format', 'json', ...(sandbox
-                ? ['--permission-mode', 'dontAsk', '--allowedTools', ...CLAUDE_SANDBOX_TOOLS, ...servers.map(server => `mcp__${server.name}`)]
-                : ['--dangerously-skip-permissions'])];
-        if (configuration.model !== DEFAULT)
-            args.push('--model', configuration.model);
-        if (configuration.reasoning !== DEFAULT)
-            args.push('--effort', configuration.reasoning);
-        if (servers.length > 0)
-            args.push('--mcp-config', join(options.directory, 'mcp.json'));
-        return { command: 'claude', args: [...args, ...extra], env, cwd };
-    }
-    const args = ['exec', '--skip-git-repo-check', ...(sandbox ? ['--sandbox', 'read-only', '-c', 'approval_policy="never"'] : ['--dangerously-bypass-approvals-and-sandbox']),
-        '--output-last-message', join(options.directory, 'last-message.md')];
-    if (configuration.model !== DEFAULT)
-        args.push('-m', configuration.model);
-    if (configuration.reasoning !== DEFAULT)
-        args.push('-c', `model_reasoning_effort=${JSON.stringify(configuration.reasoning)}`);
-    for (const server of servers)
-        args.push('-c', `mcp_servers.${server.name}.url=${JSON.stringify(server.url)}`, '-c', `mcp_servers.${server.name}.bearer_token_env_var=${JSON.stringify(server.variable)}`);
-    return { command: 'codex', args: [...args, ...extra, '-'], env, cwd };
-}
-export function claudeMcpConfig(servers) {
-    return JSON.stringify({
-        mcpServers: Object.fromEntries(servers.map((server, index) => [server.name.replace(/[^A-Za-z0-9_-]/g, '_') || `server_${index}`,
-            { type: 'http', url: server.url, headers: { Authorization: `Bearer \${SKILLSHARE_MCP_TOKEN_${index}}` } }])),
-    }, null, 2);
-}
-/** Reads Claude Code's --output-format json summary. */
-export function parseClaudeOutput(stdout) {
-    try {
-        const data = JSON.parse(stdout.trim().split(/\r?\n/).filter(Boolean).at(-1) ?? '');
-        const usage = data.usage ?? {};
-        const input = [usage.input_tokens, usage.cache_creation_input_tokens, usage.cache_read_input_tokens]
-            .filter((value) => typeof value === 'number');
-        return {
-            result: typeof data.result === 'string' ? data.result : undefined,
-            isError: data.is_error === true,
-            stats: {
-                durationMs: typeof data.duration_ms === 'number' ? data.duration_ms : undefined,
-                turns: typeof data.num_turns === 'number' ? data.num_turns : undefined,
-                costUsd: typeof data.total_cost_usd === 'number' ? data.total_cost_usd : undefined,
-                inputTokens: input.length > 0 ? input.reduce((a, b) => a + b, 0) : undefined,
-                outputTokens: typeof usage.output_tokens === 'number' ? usage.output_tokens : undefined,
-            },
-        };
-    }
-    catch {
-        return { isError: false, stats: {} };
-    }
-}
-export async function runAgent(assignment, options) {
-    const now = options.now ?? Date.now;
-    const started = now();
-    const directory = await mkdtemp(join(tmpdir(), 'skillshare-agent-'));
-    try {
-        const command = buildAgentCommand(assignment, { directory, workdir: options.workdir, profile: options.profile, sandbox: options.sandbox });
-        if (assignment.configuration.agent === 'claude' && assignment.mcpServers.length > 0)
-            await writeFile(join(directory, 'mcp.json'), claudeMcpConfig(assignment.mcpServers), { mode: 0o600 });
-        const prompt = assignment.prompt + (isSandboxed(assignment, options) ? SANDBOX_NOTE : '');
-        const outcome = await execute(command, prompt, Math.max(1, assignment.timeoutSeconds) * 1000, options.signal, options.spawnAgent ?? spawn);
-        const measured = { durationMs: now() - started };
-        const claude = assignment.configuration.agent === 'claude' ? parseClaudeOutput(outcome.stdout) : undefined;
-        const stats = { ...measured, ...Object.fromEntries(Object.entries(claude?.stats ?? {}).filter(([, value]) => value !== undefined)) };
-        if (outcome.cancelled)
-            return { ok: false, reason: 'Cancelled on request.', cancelled: true, stats };
-        if (outcome.timedOut)
-            return { ok: false, reason: `The agent did not finish within ${assignment.timeoutSeconds} seconds.`, cancelled: false, stats };
-        if (outcome.spawnError)
-            return { ok: false, reason: `Could not start ${command.command}: ${outcome.spawnError}`, cancelled: false, stats };
-        const answer = await readAnswer(directory, assignment.configuration.agent, claude?.result);
-        if (outcome.code !== 0 || claude?.isError) {
-            const detail = (claude?.isError ? claude.result : undefined) ?? lastLines(outcome.stderr) ?? `exit code ${outcome.code}`;
-            return { ok: false, reason: `${command.command} failed: ${detail}`.slice(0, 500), cancelled: false, stats };
-        }
-        if (!answer)
-            return { ok: false, reason: 'The agent finished without an answer.', cancelled: false, stats };
-        return { ok: true, markdown: answer, stats };
-    }
-    finally {
-        await rm(directory, { recursive: true, force: true });
-    }
-}
-async function readAnswer(directory, agent, claudeResult) {
-    for (const file of ['result.md', ...(agent === 'codex' ? ['last-message.md'] : [])]) {
-        try {
-            const text = (await readFile(join(directory, file), 'utf8')).trim();
-            if (text)
-                return text;
-        }
-        catch { }
-    }
-    return claudeResult?.trim() || undefined;
-}
-function lastLines(text) {
-    const lines = text.trim().split(/\r?\n/).filter(line => line.trim()).slice(-3).join(' ').trim();
-    return lines ? lines.slice(-300) : undefined;
-}
-function execute(command, input, timeoutMs, signal, spawnAgent) {
-    return new Promise(resolvePromise => {
-        const posix = process.platform !== 'win32';
-        const child = spawnAgent(command.command, command.args, {
-            cwd: command.cwd, env: { ...process.env, ...command.env }, stdio: ['pipe', 'pipe', 'pipe'],
-            // A separate process group lets cancellation stop the agent's own child processes too.
-            detached: posix, windowsHide: true, shell: !posix,
-        });
-        let stdout = '';
-        let stderr = '';
-        let cancelled = false;
-        let timedOut = false;
-        let settled = false;
-        const stop = () => {
-            const kill = (sig) => {
-                try {
-                    if (posix && child.pid)
-                        process.kill(-child.pid, sig);
-                    else
-                        child.kill(sig);
-                }
-                catch { }
-            };
-            kill('SIGTERM');
-            setTimeout(() => kill('SIGKILL'), 5000).unref();
-        };
-        const onAbort = () => { cancelled = true; stop(); };
-        const timer = setTimeout(() => { timedOut = true; stop(); }, timeoutMs);
-        signal.addEventListener('abort', onAbort, { once: true });
-        const finish = (outcome) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            signal.removeEventListener('abort', onAbort);
-            resolvePromise(outcome);
-        };
-        child.stdout?.on('data', chunk => { if (stdout.length < 2_000_000)
-            stdout += chunk; });
-        child.stderr?.on('data', chunk => { stderr = (stderr + chunk).slice(-4000); });
-        child.on('error', error => finish({ code: null, stdout, stderr, cancelled, timedOut, spawnError: error.message }));
-        child.on('close', code => finish({ code, stdout, stderr, cancelled, timedOut }));
-        child.stdin?.on('error', () => { });
-        child.stdin?.end(input);
-        if (signal.aborted)
-            onAbort();
-    });
-}