Shareone

const {
    hasSudoworkApiKey,
    isSudowork,
    readLocalApiKey,
} = require('./shareone_client');

async function checkApiKey() {
    if (isSudowork()) {
        try {
            const found = await hasSudoworkApiKey();
            console.log(found ? 'SUDOWORK_KEY_FOUND' : 'SUDOWORK_KEY_NOT_FOUND');
        } catch (_) {
            console.log('SUDOWORK_KEY_NOT_FOUND');
        }
        return;
    }

    let apiKey = process.env.SHAREONE_API_KEY || readLocalApiKey();
    if (apiKey) {
        console.log(`KEY_FOUND:${apiKey}`);
        return;
    }

    console.log("KEY_NOT_FOUND");
}

checkApiKey().catch((error) => {
    console.error(`ERROR:${error.message}`);
    process.exit(1);
});

const {
    isSudowork,
    requestPublicShareOneJson,
    requestShareOneJson,
    saveLocalApiKey,
    saveSudoworkApiKey,
} = require('./shareone_client');

async function createGuestKey() {
    try {
        const requestJson = isSudowork() ? requestPublicShareOneJson : requestShareOneJson;
        const result = await requestJson('/api/v1/agent-guest-key', {
            method: 'POST',
            authRequired: false,
        });
        if (result.api_key) {
            if (isSudowork()) {
                try {
                    await saveSudoworkApiKey(result.api_key);
                } catch (error) {
                    console.log(`ERROR:SUDOWORK_AUTH_PROXY_SAVE_FAILED:${result.api_key}`);
                    console.log("Auth Proxy 设置 ShareOne API Key 失败。请前往 Sudowork 的密钥管理手动添加 API Key，操作路径：【远程连接】-【密钥管理】。");
                    if (error && error.message) {
                        console.log(`DETAIL:${error.message}`);
                    }
                    return;
                }
            } else {
                saveLocalApiKey(result.api_key);
            }
            console.log(`GUEST_KEY_CREATED:${result.api_key}`);
            return;
        }
        console.log("ERROR:INVALID_RESPONSE");
    } catch (error) {
        if (error.statusCode === 429) {
            console.log("ERROR:RATE_LIMIT_EXCEEDED");
        } else {
            console.log(`ERROR:${error.message}`);
        }
    }
}

createGuestKey();

#!/usr/bin/env node

const {
    deleteLocalApiKey,
    deleteSudoworkApiKey,
    isSudowork,
} = require('./shareone_client');

async function deleteApiKey() {
    if (isSudowork()) {
        await deleteSudoworkApiKey();
        console.log("SUDOWORK_KEY_DELETED");
        return;
    }

    const deleted = deleteLocalApiKey();
    console.log(deleted ? "KEY_DELETED" : "KEY_NOT_FOUND");
}

deleteApiKey().catch((error) => {
    console.error(`ERROR:${error.message}`);
    process.exit(1);
});

#!/usr/bin/env node

const {
    hasSudoworkApiKey,
    isSudowork,
    requestShareOneBuffer,
    resolveDirectApiKey,
} = require('./shareone_client');

const args = process.argv.slice(2);
let ref = null;
let password = null;
let apiKey = null;
let publicOnly = false;

for (let i = 0; i < args.length; i++) {
    if (args[i] === '--ref') {
        ref = args[++i];
    } else if (args[i] === '--password') {
        password = args[++i];
    } else if (args[i] === '--api-key') {
        apiKey = args[++i];
    } else if (args[i] === '--public-only') {
        publicOnly = true;
    } else if (!args[i].startsWith('--') && !ref) {
        ref = args[i];
    }
}

if (!ref) {
    console.error("Usage: node download_share.js <ref> [--password <password>] [--api-key <key>] [--public-only]");
    process.exit(1);
}

if (isSudowork() && apiKey && !publicOnly) {
    console.error("ERROR:SUDOWORK_MANAGED_KEY");
    console.error("Sudowork 模式下不要传 --api-key；请通过本 skill 的 save_api_key.js 或 create_guest_key.js 设置 ShareOne API Key。");
    process.exit(1);
}

function extractShareRef(value) {
    const raw = String(value || '').trim();
    if (!raw) return null;
    try {
        const parsed = raw.includes('://') ? new URL(raw) : null;
        const path = parsed ? parsed.pathname : raw.split('?')[0].split('#')[0];
        const parts = path.split('/').filter(Boolean);
        if (parts.length === 0) return raw;
        if (parts[0] === 'file' && parts.length >= 2) return parts[1];
        if (parts[0] === 'api' && parts.includes('shares')) {
            const index = parts.indexOf('shares');
            return parts[index + 1] || raw;
        }
        return parts[parts.length - 1] || raw;
    } catch (_) {
        return raw;
    }
}

async function tryOwnerDownload() {
    if (publicOnly) return null;
    let hasKey = Boolean(resolveDirectApiKey(apiKey));
    if (isSudowork()) {
        try {
            hasKey = await hasSudoworkApiKey();
        } catch (_) {
            hasKey = false;
        }
    }
    if (!hasKey) return null;
    const shareRef = extractShareRef(ref);
    if (!shareRef) return null;
    try {
        return await requestShareOneBuffer(`/api/v1/shares/${encodeURIComponent(shareRef)}/download`, {
            method: 'GET',
            apiKey,
            authRequired: true,
        });
    } catch (error) {
        if ([401, 403, 404].includes(error.statusCode)) return null;
        throw error;
    }
}

async function publicDownload() {
    if (password !== null) {
        const body = JSON.stringify({ ref, password });
        return requestShareOneBuffer('/api/v1/public-download', {
            method: 'POST',
            authRequired: false,
            headers: {
                'Content-Type': 'application/json',
                'Content-Length': Buffer.byteLength(body),
            },
        }, body);
    }
    return requestShareOneBuffer(`/api/v1/public-download?ref=${encodeURIComponent(ref)}`, {
        method: 'GET',
        authRequired: false,
    });
}

(async () => {
    const ownerResult = await tryOwnerDownload();
    const result = ownerResult || await publicDownload();
    process.stdout.write(result.data);
})().catch((error) => {
    let code = null;
    try {
        const parsed = JSON.parse(error.responseText || '{}');
        const detail = parsed.detail || {};
        code = typeof detail === 'string' ? detail : detail.code;
    } catch (_) {
        // Keep the original HTTP error if the response is not JSON.
    }
    if (code) {
        console.error(`ERROR:${code}`);
    } else {
        console.error(`ERROR:${error.message}`);
    }
    process.exit(1);
});

const { isSudowork, saveLocalApiKey, saveSudoworkApiKey } = require('./shareone_client');

const apiKey = process.argv[2];
if (!apiKey) {
    console.error("Please provide an API key.");
    process.exit(1);
}

async function saveApiKey() {
    if (isSudowork()) {
        await saveSudoworkApiKey(apiKey);
        console.log("SUDOWORK_KEY_SAVED");
        return;
    }

    saveLocalApiKey(apiKey);
    console.log("KEY_SAVED");
}

saveApiKey().catch((error) => {
    if (isSudowork()) {
        console.error("ERROR:SUDOWORK_AUTH_PROXY_SAVE_FAILED");
        console.error("Auth Proxy 设置 ShareOne API Key 失败。请前往 Sudowork 的密钥管理手动添加 API Key，操作路径：【远程连接】-【密钥管理】。");
        if (error && error.message) {
            console.error(`DETAIL:${error.message}`);
        }
        process.exit(1);
    }
    console.error(`ERROR:${error.message}`);
    process.exit(1);
});

#!/usr/bin/env node

const {
    isSudowork,
    printShareOneScriptError,
    requestShareOneBuffer,
    resolveDirectApiKey,
} = require('./shareone_client');

const args = process.argv.slice(2);
let method = 'GET';
let apiPath = null;
let data = null;
let apiKey = null;
let publicRequest = false;

for (let i = 0; i < args.length; i++) {
    if (args[i] === '--method') {
        method = String(args[++i] || 'GET').toUpperCase();
    } else if (args[i] === '--data') {
        data = args[++i];
    } else if (args[i] === '--api-key') {
        apiKey = args[++i];
    } else if (args[i] === '--public') {
        publicRequest = true;
    } else if (!args[i].startsWith('--') && !apiPath) {
        apiPath = args[i];
    }
}

if (!apiPath) {
    console.error("Usage: node shareone_api_request.js <api_path> [--method GET|POST|PUT|DELETE] [--data '<json>'] [--api-key <key>] [--public]");
    process.exit(1);
}

if (isSudowork() && apiKey && !publicRequest) {
    console.error("ERROR:SUDOWORK_MANAGED_KEY");
    console.error("Sudowork 模式下不要传 --api-key；请通过本 skill 的 save_api_key.js 或 create_guest_key.js 设置 ShareOne API Key。");
    process.exit(1);
}

if (!publicRequest && !isSudowork() && !resolveDirectApiKey(apiKey)) {
    console.error("ERROR:KEY_NOT_FOUND");
    process.exit(1);
}

const headers = {};
let body = null;
if (data !== null) {
    body = data;
    headers['Content-Type'] = 'application/json';
    headers['Content-Length'] = Buffer.byteLength(body);
}

requestShareOneBuffer(apiPath, {
    method,
    apiKey,
    authRequired: !publicRequest,
    headers,
}, body).then((res) => {
    process.stdout.write(res.data);
}).catch((error) => {
    printShareOneScriptError(error);
    process.exit(1);
});

const http = require('http');
const https = require('https');
const os = require('os');
const fs = require('fs');
const path = require('path');

const DEFAULT_BASE_URL = 'https://shareone.app';
const CREDENTIALS_PATH = path.join(os.homedir(), '.shareone_credentials');
const SUDOWORK_SECRET_NAMESPACE = 'service:shareone';
const SUDOWORK_SECRET_KEY = 'X-API-Key';

function isSudowork() {
    return Boolean(process.env.SUDOWORK_AUTH_PROXY_URL && process.env.SUDOWORK_AUTH_PROXY_TOKEN);
}

function getSudoworkBaseUrl() {
    return process.env.SUDOWORK_AUTH_PROXY_BASE_URL || String(process.env.SUDOWORK_AUTH_PROXY_URL || '').replace(/\/proxy\/?$/, '');
}

function getBaseUrl() {
    return process.env.SHAREONE_BASE_URL || DEFAULT_BASE_URL;
}

function getCredentialsPath() {
    return CREDENTIALS_PATH;
}

function readLocalApiKey() {
    if (!fs.existsSync(CREDENTIALS_PATH)) return null;
    try {
        const data = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf8'));
        return data && data.api_key ? data.api_key : null;
    } catch (_) {
        return null;
    }
}

function resolveDirectApiKey(explicitApiKey) {
    return explicitApiKey || process.env.SHAREONE_API_KEY || readLocalApiKey();
}

function saveLocalApiKey(apiKey) {
    fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify({ api_key: apiKey }));
}

function deleteLocalApiKey() {
    if (!fs.existsSync(CREDENTIALS_PATH)) return false;
    fs.unlinkSync(CREDENTIALS_PATH);
    return true;
}

function appendPath(baseUrl, apiPath) {
    const trimmedBase = String(baseUrl).replace(/\/+$/, '');
    const normalizedPath = apiPath.startsWith('/') ? apiPath : `/${apiPath}`;
    return `${trimmedBase}${normalizedPath}`;
}

function requestBuffer(url, options = {}, body = null) {
    return new Promise((resolve, reject) => {
        const target = new URL(url);
        const client = target.protocol === 'https:' ? https : http;
        const req = client.request(target, {
            method: options.method || 'GET',
            headers: options.headers || {},
        }, (res) => {
            const chunks = [];
            res.on('data', chunk => chunks.push(Buffer.from(chunk)));
            res.on('end', () => {
                const data = Buffer.concat(chunks);
                const text = data.toString('utf8');
                if (res.statusCode >= 200 && res.statusCode < 300) {
                    resolve({ statusCode: res.statusCode, headers: res.headers, data, text });
                    return;
                }
                const error = new Error(`HTTP ${res.statusCode}: ${text}`);
                error.statusCode = res.statusCode;
                error.responseText = text;
                reject(error);
            });
        });

        req.on('error', reject);
        if (options.timeoutMs) {
            req.setTimeout(options.timeoutMs, () => {
                req.destroy(new Error('Request timed out'));
            });
        }
        if (body) req.write(body);
        req.end();
    });
}

function buildJsonRequestBody(payload) {
    const body = payload === null ? null : JSON.stringify(payload);
    const headers = { 'Content-Type': 'application/json' };
    if (body !== null) headers['Content-Length'] = Buffer.byteLength(body);
    return { body, headers };
}

async function requestJsonUrl(url, options = {}, payload = null) {
    const { body, headers } = buildJsonRequestBody(payload);
    const res = await requestBuffer(url, {
        ...options,
        headers: {
            ...headers,
            ...(options.headers || {}),
        },
    }, body);
    return JSON.parse(res.text);
}

async function requestPublicShareOneJson(apiPath, options = {}, payload = null) {
    return requestJsonUrl(appendPath(getBaseUrl(), apiPath), options, payload);
}

function buildSudoworkSecretsUrl(pathSuffix = '') {
    const baseUrl = getSudoworkBaseUrl();
    if (!baseUrl) {
        throw new Error('SUDOWORK_AUTH_PROXY_BASE_URL is not available');
    }
    return appendPath(baseUrl, `/secrets${pathSuffix}`);
}

async function requestSudoworkSecrets(pathSuffix = '', options = {}, payload = null) {
    if (!isSudowork()) {
        throw new Error('Sudowork environment is not available');
    }
    const { body, headers } = buildJsonRequestBody(payload);
    const res = await requestBuffer(buildSudoworkSecretsUrl(pathSuffix), {
        ...options,
        headers: {
            ...headers,
            ...(options.headers || {}),
            Authorization: `Bearer ${process.env.SUDOWORK_AUTH_PROXY_TOKEN}`,
        },
    }, body);
    return JSON.parse(res.text);
}

async function listSudoworkSecrets(namespace = SUDOWORK_SECRET_NAMESPACE) {
    const query = `?namespace=${encodeURIComponent(namespace)}`;
    const result = await requestSudoworkSecrets(query, { method: 'GET' }, null);
    return Array.isArray(result.data) ? result.data : [];
}

async function hasSudoworkApiKey() {
    const secrets = await listSudoworkSecrets(SUDOWORK_SECRET_NAMESPACE);
    return secrets.some(secret => secret && secret.namespace === SUDOWORK_SECRET_NAMESPACE && secret.key === SUDOWORK_SECRET_KEY);
}

async function saveSudoworkApiKey(apiKey) {
    const pathSuffix = `/${encodeURIComponent(SUDOWORK_SECRET_NAMESPACE)}/${encodeURIComponent(SUDOWORK_SECRET_KEY)}`;
    return requestSudoworkSecrets(pathSuffix, { method: 'PUT' }, {
        value: apiKey,
        description: 'ShareOne API Key',
    });
}

async function deleteSudoworkApiKey() {
    const pathSuffix = `/${encodeURIComponent(SUDOWORK_SECRET_NAMESPACE)}/${encodeURIComponent(SUDOWORK_SECRET_KEY)}`;
    return requestSudoworkSecrets(pathSuffix, { method: 'DELETE' }, null);
}

function buildShareOneRequest(apiPath, options = {}) {
    const targetUrl = appendPath(getBaseUrl(), apiPath);
    const headers = { ...(options.headers || {}) };

    if (isSudowork() && options.authRequired !== false) {
        delete headers['X-API-Key'];
        delete headers['x-api-key'];
        return {
            url: process.env.SUDOWORK_AUTH_PROXY_URL,
            options: {
                ...options,
                headers: {
                    ...headers,
                    Authorization: `Bearer ${process.env.SUDOWORK_AUTH_PROXY_TOKEN}`,
                    'X-Secret-Namespace': 'service:shareone',
                    'X-Remote-URL': targetUrl,
                    'X-Auth-Scheme': 'header',
                    'X-Auth-Header': 'X-API-Key',
                    'X-Secret-Key': 'X-API-Key'
                },
            },
        };
    }

    if (options.authRequired !== false) {
        const apiKey = resolveDirectApiKey(options.apiKey);
        if (apiKey) headers['X-API-Key'] = apiKey;
    }

    return {
        url: targetUrl,
        options: {
            ...options,
            headers,
        },
    };
}

async function requestShareOneBuffer(apiPath, options = {}, body = null) {
    const built = buildShareOneRequest(apiPath, options);
    return requestBuffer(built.url, built.options, body);
}

async function requestShareOneJson(apiPath, options = {}, payload = null) {
    const { body, headers } = buildJsonRequestBody(payload);

    const res = await requestShareOneBuffer(apiPath, {
        ...options,
        headers: {
            ...headers,
            ...(options.headers || {}),
        },
    }, body);
    return JSON.parse(res.text);
}

function getErrorDetail(error) {
    const text = String(error && error.responseText ? error.responseText : '');
    if (!text) return '';
    try {
        const parsed = JSON.parse(text);
        return String(parsed.detail || parsed.message || text);
    } catch (_) {
        return text;
    }
}

function isSudoworkMissingKeyError(error) {
    if (!error) return false;
    const detail = getErrorDetail(error);

    if (error.statusCode === 502) {
        return /secret|key|credential|not found|missing|未配置|不存在|缺少/i.test(detail || error.message || '');
    }

    if (error.statusCode !== 401) return false;
    return /Missing API Key/i.test(detail);
}

function isAuthFailedError(error) {
    if (!error) return false;
    if (error.statusCode === 401 || error.statusCode === 403) return true;
    const detail = getErrorDetail(error);
    return /Invalid API Key|Inactive user|unauthorized|forbidden|权限不足|无效/i.test(detail || error.message || '');
}

function printShareOneScriptError(error) {
    if (isSudowork() && isSudoworkMissingKeyError(error)) {
        console.error("ERROR:SUDOWORK_KEY_NOT_FOUND");
        console.error("请先运行 check_api_key.js，并按提示通过 save_api_key.js 或 create_guest_key.js 设置 ShareOne API Key。");
        return;
    }

    if (isAuthFailedError(error)) {
        console.error("ERROR:AUTH_FAILED");
        console.error("API Key 无效或权限不足。");
        return;
    }

    console.error(`ERROR:${error.message}`);
}

module.exports = {
    DEFAULT_BASE_URL,
    SUDOWORK_SECRET_KEY,
    SUDOWORK_SECRET_NAMESPACE,
    appendPath,
    deleteLocalApiKey,
    deleteSudoworkApiKey,
    getBaseUrl,
    getCredentialsPath,
    hasSudoworkApiKey,
    isSudowork,
    isAuthFailedError,
    isSudoworkMissingKeyError,
    listSudoworkSecrets,
    printShareOneScriptError,
    readLocalApiKey,
    requestBuffer,
    requestPublicShareOneJson,
    requestShareOneBuffer,
    requestShareOneJson,
    resolveDirectApiKey,
    saveLocalApiKey,
    saveSudoworkApiKey,
};

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const {
    isSudowork,
    printShareOneScriptError,
    requestBuffer,
    requestShareOneBuffer,
    requestShareOneJson,
    resolveDirectApiKey,
} = require('./shareone_client');

function getMimeType(filePath) {
    const ext = path.extname(filePath).toLowerCase();
    const mimeTypes = {
        '.html': 'text/html',
        '.htm': 'text/html',
        '.md': 'text/markdown',
        '.txt': 'text/plain',
        '.pdf': 'application/pdf',
        '.ppt': 'application/vnd.ms-powerpoint',
        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
        '.doc': 'application/msword',
        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
        '.png': 'image/png',
        '.jpg': 'image/jpeg',
        '.jpeg': 'image/jpeg',
        '.gif': 'image/gif',
        '.zip': 'application/zip'
    };
    return mimeTypes[ext] || 'application/octet-stream';
}

function buildMultipartBody(fields, filePath, filename, contentType) {
    const boundary = '----ShareOneBoundary' + crypto.randomBytes(16).toString('hex');
    const fileData = fs.readFileSync(filePath);
    const bodyParts = [];

    for (const [key, value] of Object.entries(fields || {})) {
        if (value === undefined || value === null) continue;
        bodyParts.push(Buffer.from(`--${boundary}\r\n`));
        bodyParts.push(Buffer.from(`Content-Disposition: form-data; name="${key}"\r\n\r\n`));
        bodyParts.push(Buffer.from(`${value}\r\n`));
    }

    bodyParts.push(Buffer.from(`--${boundary}\r\n`));
    bodyParts.push(Buffer.from(`Content-Disposition: form-data; name="file"; filename="${filename}"\r\n`));
    bodyParts.push(Buffer.from(`Content-Type: ${contentType}\r\n\r\n`));
    bodyParts.push(fileData);
    bodyParts.push(Buffer.from('\r\n'));
    bodyParts.push(Buffer.from(`--${boundary}--\r\n`));

    return { body: Buffer.concat(bodyParts), boundary };
}

async function uploadToAzure(uploadUrl, filePath, contentType) {
    const fileData = fs.readFileSync(filePath);
    await requestBuffer(uploadUrl, {
        method: 'PUT',
        headers: {
            'x-ms-blob-type': 'BlockBlob',
            'Content-Type': contentType,
            'Content-Length': fileData.length
        }
    }, fileData);
}

async function uploadToS3(uploadUrl, uploadFields, filePath, filename, contentType) {
    const { body, boundary } = buildMultipartBody(uploadFields, filePath, filename, contentType);
    await requestBuffer(uploadUrl, {
        method: 'POST',
        headers: {
            'Content-Type': `multipart/form-data; boundary=${boundary}`,
            'Content-Length': body.length
        }
    }, body);
}

async function uploadMultipartFallback(filePath, filename, contentType, options) {
    const fields = {};
    if (options.password) fields.password = options.password;
    if (options.watermark) fields.watermark = options.watermark;
    if (options.slug) fields.custom_slug = options.slug;
    const { body, boundary } = buildMultipartBody(fields, filePath, filename, contentType);
    const res = await requestShareOneBuffer('/api/v1/files', {
        method: 'POST',
        apiKey: options.apiKey,
        headers: {
            'Content-Type': `multipart/form-data; boundary=${boundary}`,
            'Content-Length': body.length
        }
    }, body);
    return JSON.parse(res.text);
}

function shouldFallbackToMultipart(error) {
    const detail = String(error.responseText || error.message || '');
    return error.statusCode === 400 && detail.includes('Direct upload is only supported');
}

async function uploadFile(filePath, options) {
    if (!fs.existsSync(filePath)) {
        console.error(`Error: File not found: ${filePath}`);
        process.exit(1);
    }

    if (isSudowork() && options.apiKey) {
        console.error("ERROR:SUDOWORK_MANAGED_KEY");
        console.error("Sudowork 模式下不要传 --api-key；请通过本 skill 的 save_api_key.js 或 create_guest_key.js 设置 ShareOne API Key。");
        process.exit(1);
    }

    if (!isSudowork() && !resolveDirectApiKey(options.apiKey)) {
        console.error("ERROR:KEY_NOT_FOUND");
        process.exit(1);
    }

    const filename = options.filename || path.basename(filePath);
    const contentType = options.contentType || getMimeType(filePath);

    try {
        const credential = await requestShareOneJson('/api/v1/files/credential', {
            method: 'POST',
            apiKey: options.apiKey,
        }, {
            filename: filename,
            content_type: contentType,
            custom_slug: options.slug || undefined
        });

        if (credential.upload_type === 'azure') {
            await uploadToAzure(credential.upload_url, filePath, contentType);
        } else {
            await uploadToS3(credential.upload_url, credential.upload_fields || {}, filePath, filename, contentType);
        }

        const confirmPayload = {
            share_id: credential.share_id,
            filename: filename,
            content_type: contentType
        };
        if (options.password) confirmPayload.password = options.password;
        if (options.watermark) confirmPayload.watermark = options.watermark;
        if (options.slug) confirmPayload.custom_slug = options.slug;

        const finalRes = await requestShareOneJson('/api/v1/files/confirm', {
            method: 'POST',
            apiKey: options.apiKey,
        }, confirmPayload);

        console.log(JSON.stringify(finalRes));
        return finalRes.share_url;
    } catch (error) {
        if (shouldFallbackToMultipart(error)) {
            const finalRes = await uploadMultipartFallback(filePath, filename, contentType, options);
            console.log(JSON.stringify(finalRes));
            return finalRes.share_url;
        }
        throw error;
    }
}

const args = process.argv.slice(2);
let filePath = null;
const options = {
    apiKey: null,
    filename: null,
    contentType: null,
    password: null,
    watermark: null,
    slug: null,
};

for (let i = 0; i < args.length; i++) {
    if (args[i] === '--api-key') {
        options.apiKey = args[++i];
    } else if (args[i] === '--base-url') {
        process.env.SHAREONE_BASE_URL = args[++i];
    } else if (args[i] === '--filename') {
        options.filename = args[++i];
    } else if (args[i] === '--content-type') {
        options.contentType = args[++i];
    } else if (args[i] === '--password') {
        options.password = args[++i];
    } else if (args[i] === '--watermark') {
        options.watermark = args[++i];
    } else if (args[i] === '--slug') {
        options.slug = args[++i];
    } else if (!args[i].startsWith('--')) {
        filePath = args[i];
    }
}

if (!filePath) {
    console.error("Usage: node shareone_upload.js <file_path> [--api-key <api_key>] [--base-url <base_url>] [--filename <name>] [--content-type <mime>] [--password <password>] [--watermark <watermark>] [--slug <slug>]");
    process.exit(1);
}

uploadFile(filePath, options).catch((error) => {
    printShareOneScriptError(error);
    process.exit(1);
});

#!/usr/bin/env node

const {
    getBaseUrl,
    isSudowork,
    printShareOneScriptError,
    requestShareOneBuffer,
    resolveDirectApiKey,
} = require('./shareone_client');

const args = process.argv.slice(2);
let ref = null;
let apiKey = null;
let dryRun = false;
let explicitBaseUrl = null;
const payload = {};

function usage() {
    console.error('Usage: node update_share_settings.js <share_link_or_id> [--api-key <key>] [--base-url <url>] [--watermark <text>] [--password <pwd>] [--slug <slug>] [--allow-comments <true|false>] [--dry-run]');
}

function nextValue(index, flag) {
    const value = args[index + 1];
    if (value === undefined) {
        console.error(`ERROR:MISSING_VALUE:${flag}`);
        usage();
        process.exit(1);
    }
    return value;
}

function parseBoolean(value, flag) {
    if (value === 'true') return true;
    if (value === 'false') return false;
    console.error(`ERROR:INVALID_BOOLEAN:${flag}`);
    console.error(`${flag} must be true or false.`);
    process.exit(1);
}

for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    if (arg === '--api-key') {
        apiKey = nextValue(i, arg);
        i += 1;
    } else if (arg === '--base-url') {
        explicitBaseUrl = nextValue(i, arg);
        process.env.SHAREONE_BASE_URL = explicitBaseUrl;
        i += 1;
    } else if (arg === '--watermark') {
        payload.watermark = nextValue(i, arg);
        i += 1;
    } else if (arg === '--password') {
        payload.password = nextValue(i, arg);
        i += 1;
    } else if (arg === '--slug' || arg === '--custom-slug') {
        payload.custom_slug = nextValue(i, arg);
        i += 1;
    } else if (arg === '--allow-comments') {
        payload.allow_comments = parseBoolean(nextValue(i, arg), arg);
        i += 1;
    } else if (arg === '--dry-run') {
        dryRun = true;
    } else if (!arg.startsWith('--') && !ref) {
        ref = arg;
    } else {
        console.error(`ERROR:UNKNOWN_ARGUMENT:${arg}`);
        usage();
        process.exit(1);
    }
}

if (!ref) {
    usage();
    process.exit(1);
}

if (Object.keys(payload).length === 0) {
    console.error('ERROR:NO_SETTINGS_PROVIDED');
    console.error('Provide at least one of --watermark, --password, --slug, or --allow-comments.');
    process.exit(1);
}

if (isSudowork() && apiKey && !dryRun) {
    console.error('ERROR:SUDOWORK_MANAGED_KEY');
    console.error('Sudowork 模式下不要传 --api-key；请通过本 skill 的 save_api_key.js 或 create_guest_key.js 设置 ShareOne API Key。');
    process.exit(1);
}

if (!dryRun && !isSudowork() && !resolveDirectApiKey(apiKey)) {
    console.error('ERROR:KEY_NOT_FOUND');
    process.exit(1);
}

function parseRef(input) {
    const raw = String(input || '').trim();
    let path = raw.split('?')[0].split('#')[0];

    try {
        if (raw.includes('://')) {
            const parsed = new URL(raw);
            if (!explicitBaseUrl) {
                process.env.SHAREONE_BASE_URL = `${parsed.protocol}//${parsed.host}`;
            }
            path = parsed.pathname;
        }
    } catch (_) {
        path = raw.split('?')[0].split('#')[0];
    }

    const parts = path.split('/').filter(Boolean);
    const knownPrefixes = new Set(['s', 'md', 'pdf', 'ppt', 'word']);

    if (parts.length >= 2 && knownPrefixes.has(parts[0])) {
        return { prefix: parts[0], shareRef: parts[1] };
    }

    return { prefix: null, shareRef: parts[parts.length - 1] || raw };
}

function endpointForPrefix(prefix, shareRef) {
    const encodedRef = encodeURIComponent(shareRef);
    if (prefix === 's' || prefix === 'md') {
        return `/api/v1/pages/${encodedRef}`;
    }
    if (prefix === 'pdf' || prefix === 'ppt' || prefix === 'word') {
        return `/api/v1/files/${encodedRef}`;
    }
    return null;
}

function buildRequestBody() {
    const body = JSON.stringify(payload);
    return {
        body,
        headers: {
            'Content-Type': 'application/json',
            'Content-Length': Buffer.byteLength(body),
        },
    };
}

function shouldRetryAsFile(error) {
    const text = `${error && error.message ? error.message : ''}\n${error && error.responseText ? error.responseText : ''}`;
    return error && error.statusCode === 400 && /only for HTML\/Markdown|Use \/api\/v1\/files|HTML\/Markdown pages/i.test(text);
}

async function putSettings(apiPath) {
    const { body, headers } = buildRequestBody();
    return requestShareOneBuffer(apiPath, {
        method: 'PUT',
        apiKey,
        headers,
    }, body);
}

(async () => {
    const parsed = parseRef(ref);
    const explicitApiPath = endpointForPrefix(parsed.prefix, parsed.shareRef);
    const pageApiPath = `/api/v1/pages/${encodeURIComponent(parsed.shareRef)}`;
    const fileApiPath = `/api/v1/files/${encodeURIComponent(parsed.shareRef)}`;

    if (dryRun) {
        const result = {
            method: 'PUT',
            api_path: explicitApiPath || pageApiPath,
            payload,
            base_url: getBaseUrl(),
        };
        if (!explicitApiPath) {
            result.fallback_api_path = fileApiPath;
        }
        console.log(JSON.stringify(result, null, 2));
        return;
    }

    if (explicitApiPath) {
        const res = await putSettings(explicitApiPath);
        process.stdout.write(res.data);
        return;
    }

    try {
        const res = await putSettings(pageApiPath);
        process.stdout.write(res.data);
    } catch (error) {
        if (!shouldRetryAsFile(error)) {
            throw error;
        }
        const res = await putSettings(fileApiPath);
        process.stdout.write(res.data);
    }
})().catch((error) => {
    printShareOneScriptError(error);
    process.exit(1);
});

const fs = require('fs');
const path = require('path');
const {
    isSudowork,
    printShareOneScriptError,
    requestShareOneBuffer,
    resolveDirectApiKey,
} = require('./shareone_client');

const args = process.argv.slice(2);
let filePath = null;
let apiKey = null;
let filename = null;
let password = null;
let watermark = null;
let shareId = null;
let allowComments = null;
let slug = null;

for (let i = 0; i < args.length; i++) {
    if (args[i] === '--api-key') {
        apiKey = args[++i];
    } else if (args[i] === '--filename') {
        filename = args[++i];
    } else if (args[i] === '--password') {
        password = args[++i];
    } else if (args[i] === '--watermark') {
        watermark = args[++i];
    } else if (args[i] === '--share-id') {
        shareId = args[++i];
    } else if (args[i] === '--slug') {
        slug = args[++i];
    } else if (args[i] === '--allow-comments') {
        allowComments = args[++i] === 'true';
    } else if (!args[i].startsWith('--')) {
        filePath = args[i];
    }
}

if (!filePath) {
    console.error("Usage: node upload_page.js <file_path> [--api-key <key>] [--filename <name>] [--password <pwd>] [--watermark <wm>] [--share-id <id>] [--slug <slug>] [--allow-comments <true|false>]");
    process.exit(1);
}

if (!filename) {
    filename = path.basename(filePath);
}

if (isSudowork() && apiKey) {
    console.error("ERROR:SUDOWORK_MANAGED_KEY");
    console.error("Sudowork 模式下不要传 --api-key；请通过本 skill 的 save_api_key.js 或 create_guest_key.js 设置 ShareOne API Key。");
    process.exit(1);
}

if (!isSudowork() && !resolveDirectApiKey(apiKey)) {
    console.error("ERROR:KEY_NOT_FOUND");
    process.exit(1);
}

async function uploadPage() {
    const content = fs.readFileSync(filePath, "utf-8");

    const payload = {
        filename: filename,
        html_content: content
    };

    if (password !== null) payload.password = password;
    if (watermark !== null) payload.watermark = watermark;
    if (slug !== null) payload.custom_slug = slug;

    if (allowComments !== null) {
        payload.allow_comments = allowComments;
    }

    const data = JSON.stringify(payload);
    const urlPath = shareId
        ? `/api/v1/pages/${shareId}`
        : '/api/v1/pages';

    const method = shareId ? 'PUT' : 'POST';

    const res = await requestShareOneBuffer(urlPath, {
        method: method,
        apiKey,
        headers: {
            'Content-Type': 'application/json',
            'Content-Length': Buffer.byteLength(data)
        }
    }, data);

    if (shareId) {
        await verifyUpdatedContent(shareId, content);
    }

    console.log(res.text);
}

async function verifyUpdatedContent(updatedShareId, expectedContent) {
    const res = await requestShareOneBuffer(`/api/v1/shares/${encodeURIComponent(updatedShareId)}/download`, {
        method: 'GET',
        apiKey,
        headers: {
            Accept: '*/*',
        },
    });

    if (res.data.toString('utf8') !== expectedContent) {
        throw new Error('UPDATE_VERIFY_FAILED: server accepted the update but source content did not match the uploaded file');
    }
}

uploadPage().catch((error) => {
    printShareOneScriptError(error);
    process.exit(1);
});

{
  "schema_version": "2.0",
  "meta": {
    "generated_at": "2026-06-09T02:29:43.839Z",
    "slug": "sudoprivacy-shareone",
    "source_url": "https://github.com/sudoprivacy/shareone-skill/tree/main/",
    "source_ref": "main",
    "model": "claude",
    "analysis_version": "3.0.0",
    "source_type": "community",
    "content_hash": "33680c1e7a8c3824c55f7e4dde48a52e0d1f30ba24d7887a18c149894b2e7eaf",
    "tree_hash": "d238f7c9737b39482ca68f8cd9dfbef7729361c11aec259f07947a6064eed00d"
  },
  "skill": {
    "name": "shareone",
    "description": "Publish locally generated HTML, Markdown, TXT, PDF, Word, or PPTX to the ShareOne platform and generate public share links. Also handles downloading, modifying, and processing comments on existing ShareOne links.",
    "summary": "Publish files to ShareOne and manage share links, comments, and credentials from AI agent conversations.",
    "icon": "📦",
    "version": "1.0.4",
    "author": "sudoprivacy",
    "license": "MIT",
    "category": "productivity",
    "tags": [
      "file-sharing",
      "publish",
      "share-links",
      "shareone",
      "document-hosting"
    ],
    "supported_tools": [
      "claude",
      "codex",
      "claude-code"
    ],
    "risk_factors": [
      "scripts",
      "network",
      "filesystem",
      "env_access"
    ]
  },
  "security_audit": {
    "risk_level": "low",
    "is_blocked": false,
    "safe_to_publish": true,
    "summary": "Evaluation of static findings: the 442 'Ruby/shell backtick execution' matches are false positives from inline code formatting in markdown documentation (SKILL.md and workflows/*.md), not actual shell execution. The 'weak cryptographic algorithm' and 'high file entropy' findings are also false positives triggered by URLs, code samples, and base64-looking strings in markdown. The 'dangerous combination' heuristic warning reflects the skill's legitimate need for network, filesystem, and credential access to call the ShareOne API. The actual Node.js scripts are clean, use standard modules (http, https, fs, crypto), rely on HTTPS for all API calls to the documented shareone.app endpoint, and handle the API key through env var or local file rather than hardcoding it. No eval, child_process, or shell injection vectors were found.",
    "risk_factor_evidence": [
      {
        "factor": "external_commands",
        "evidence": [
          {
            "file": "scripts/check_api_key.js",
            "line_start": 20,
            "line_end": 20
          },
          {
            "file": "scripts/check_api_key.js",
            "line_start": 28,
            "line_end": 28
          },
          {
            "file": "scripts/create_guest_key.js",
            "line_start": 21,
            "line_end": 21
          },
          {
            "file": "scripts/create_guest_key.js",
            "line_start": 24,
            "line_end": 24
          },
          {
            "file": "scripts/create_guest_key.js",
            "line_start": 31,
            "line_end": 31
          },
          {
            "file": "scripts/create_guest_key.js",
            "line_start": 39,
            "line_end": 39
          },
          {
            "file": "scripts/delete_api_key.js",
            "line_start": 21,
            "line_end": 21
          },
          {
            "file": "scripts/download_share.js",
            "line_start": 74,
            "line_end": 74
          },
          {
            "file": "scripts/download_share.js",
            "line_start": 97,
            "line_end": 97
          },
          {
            "file": "scripts/download_share.js",
            "line_start": 117,
            "line_end": 117
          },
          {
            "file": "scripts/download_share.js",
            "line_start": 119,
            "line_end": 119
          },
          {
            "file": "scripts/save_api_key.js",
            "line_start": 25,
            "line_end": 25
          },
          {
            "file": "scripts/save_api_key.js",
            "line_start": 29,
            "line_end": 29
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 54,
            "line_end": 54
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 55,
            "line_end": 55
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 75,
            "line_end": 75
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 121,
            "line_end": 121
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 134,
            "line_end": 134
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 141,
            "line_end": 141
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 152,
            "line_end": 152
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 160,
            "line_end": 160
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 177,
            "line_end": 177
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 263,
            "line_end": 263
          }
        ]
      },
      {
        "factor": "env_access",
        "evidence": [
          {
            "file": "scripts/check_api_key.js",
            "line_start": 18,
            "line_end": 18
          },
          {
            "file": "scripts/create_guest_key.js",
            "line_start": 16,
            "line_end": 16
          },
          {
            "file": "scripts/create_guest_key.js",
            "line_start": 19,
            "line_end": 19
          },
          {
            "file": "scripts/create_guest_key.js",
            "line_start": 21,
            "line_end": 21
          },
          {
            "file": "scripts/create_guest_key.js",
            "line_start": 29,
            "line_end": 29
          },
          {
            "file": "scripts/create_guest_key.js",
            "line_start": 31,
            "line_end": 31
          },
          {
            "file": "scripts/download_share.js",
            "line_start": 37,
            "line_end": 37
          },
          {
            "file": "scripts/shareone_api_request.js",
            "line_start": 38,
            "line_end": 38
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 13,
            "line_end": 13
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 17,
            "line_end": 17
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 21,
            "line_end": 21
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 39,
            "line_end": 39
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 134,
            "line_end": 134
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 172,
            "line_end": 172
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 177,
            "line_end": 177
          },
          {
            "file": "scripts/shareone_upload.js",
            "line_start": 180,
            "line_end": 180
          },
          {
            "file": "scripts/shareone_upload.js",
            "line_start": 111,
            "line_end": 111
          },
          {
            "file": "scripts/shareone_upload.js",
            "line_start": 197,
            "line_end": 197
          },
          {
            "file": "scripts/update_share_settings.js",
            "line_start": 47,
            "line_end": 47
          },
          {
            "file": "scripts/update_share_settings.js",
            "line_start": 102,
            "line_end": 102
          },
          {
            "file": "scripts/update_share_settings.js",
            "line_start": 85,
            "line_end": 85
          },
          {
            "file": "scripts/upload_page.js",
            "line_start": 51,
            "line_end": 51
          }
        ]
      },
      {
        "factor": "network",
        "evidence": [
          {
            "file": "scripts/shareone_client.js",
            "line_start": 62,
            "line_end": 62
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 7,
            "line_end": 7
          },
          {
            "file": "workflows/environment-and-credentials.md",
            "line_start": 63,
            "line_end": 63
          },
          {
            "file": "workflows/environment-and-credentials.md",
            "line_start": 77,
            "line_end": 77
          },
          {
            "file": "workflows/environment-and-credentials.md",
            "line_start": 116,
            "line_end": 116
          },
          {
            "file": "workflows/environment-and-credentials.md",
            "line_start": 123,
            "line_end": 123
          },
          {
            "file": "workflows/publish-text-page.md",
            "line_start": 39,
            "line_end": 39
          },
          {
            "file": "workflows/publish-text-page.md",
            "line_start": 93,
            "line_end": 93
          },
          {
            "file": "workflows/result-and-errors.md",
            "line_start": 9,
            "line_end": 9
          },
          {
            "file": "workflows/update-share-settings.md",
            "line_start": 11,
            "line_end": 11
          },
          {
            "file": "workflows/update-share-settings.md",
            "line_start": 28,
            "line_end": 28
          }
        ]
      },
      {
        "factor": "filesystem",
        "evidence": [
          {
            "file": "scripts/shareone_client.js",
            "line_start": 31,
            "line_end": 31
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 43,
            "line_end": 43
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 48,
            "line_end": 48
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 29,
            "line_end": 29
          },
          {
            "file": "scripts/shareone_client.js",
            "line_start": 47,
            "line_end": 47
          },
          {
            "file": "scripts/shareone_upload.js",
            "line_start": 38,
            "line_end": 38
          },
          {
            "file": "scripts/shareone_upload.js",
            "line_start": 59,
            "line_end": 59
          },
          {
            "file": "scripts/shareone_upload.js",
            "line_start": 104,
            "line_end": 104
          },
          {
            "file": "scripts/upload_page.js",
            "line_start": 61,
            "line_end": 61
          }
        ]
      }
    ],
    "critical_findings": [],
    "high_findings": [],
    "medium_findings": [],
    "low_findings": [
      {
        "title": "Skill requires elevated capabilities by design",
        "description": "The skill uses Node.js scripts with network, filesystem, and env access to call the ShareOne API. This is the documented purpose of the skill, not a vulnerability, but users should be aware that any compromise of these scripts could read or modify local files and exfiltrate the ShareOne API key. The static analyzer flagged the combination as a heuristic warning, which is appropriate. Confidence is high that the actual code is benign based on review of the scripts.",
        "locations": [
          {
            "file": "scripts/shareone_client.js",
            "line_start": 1,
            "line_end": 290
          }
        ]
      }
    ],
    "dangerous_patterns": [],
    "files_scanned": 20,
    "total_lines": 1935,
    "audit_model": "claude",
    "audited_at": "2026-06-09T02:29:43.839Z",
    "risk_factors": [
      "scripts",
      "network",
      "filesystem",
      "env_access"
    ]
  },
  "content": {
    "user_title": "Publish files to ShareOne and share public links",
    "value_statement": "Sharing local files online usually means uploading, copying a link, and configuring permissions by hand. This skill automates the ShareOne workflow so Claude can publish, update, download, and moderate shared content in one conversation.",
    "seo_keywords": [
      "Claude",
      "Codex",
      "Claude Code",
      "ShareOne",
      "file sharing",
      "publish HTML",
      "public share link",
      "AI agent",
      "document publishing",
      "comment collaboration"
    ],
    "actual_capabilities": [
      "Publish HTML, Markdown, TXT, PDF, Word, and PPTX files to the ShareOne platform",
      "Generate public share links with optional password, watermark, and custom slug",
      "Update settings on existing shares without re-uploading files",
      "Download files from ShareOne links using owner credentials or public endpoints",
      "Read and process comments left on shared pages",
      "Manage ShareOne API keys via environment variables or local credential files"
    ],
    "limitations": [
      "Requires a valid ShareOne API key; only public downloads work without one",
      "Binary file content cannot be edited in place; updates require re-uploading",
      "Depends on the ShareOne service being reachable from the host machine",
      "Watermarks and passwords apply at share level, not per viewer"
    ],
    "use_cases": [
      {
        "title": "Developer publishing a generated report",
        "description": "A developer finishes generating an HTML dashboard and asks Claude to publish it to ShareOne with a custom slug and password for the team.",
        "target_user": "Software developers and technical writers"
      },
      {
        "title": "Team lead distributing project documents",
        "description": "A project manager needs to share a PDF contract with external reviewers and collect their feedback as comments on the page.",
        "target_user": "Project managers and team leads"
      },
      {
        "title": "Educator sharing lesson materials",
        "description": "A teacher exports a Markdown lesson to ShareOne, then uses the comment workflow to gather student questions and update the document.",
        "target_user": "Educators and content creators"
      }
    ],
    "prompt_templates": [
      {
        "title": "Publish a single file",
        "prompt": "Publish the file ./report.html to ShareOne and give me the share link.",
        "scenario": "Beginner: simple publish of a local file with no extra options"
      },
      {
        "title": "Publish with protection options",
        "prompt": "Upload the PDF at ./Q4-summary.pdf to ShareOne with password 'team-2026' and watermark 'Internal Only'. Return the share link.",
        "scenario": "Intermediate: text or binary file with password, watermark, or custom slug"
      },
      {
        "title": "Update settings on an existing share",
        "prompt": "Take this ShareOne link https://shareone.app/s/abc123 and set a new password 'launch-day' and disable comments.",
        "scenario": "Advanced: metadata-only update without re-uploading the source file"
      },
      {
        "title": "Process feedback and re-publish",
        "prompt": "Download the source of https://shareone.app/s/abc123, read its comments, apply the requested fixes, and publish the updated version back to the same share.",
        "scenario": "Expert: combine download, comment processing, edit, and re-publish in one workflow"
      }
    ],
    "output_examples": [
      {
        "input": "Publish index.html to ShareOne and give me the link.",
        "output": [
          "Share link: https://shareone.app/s/quarterly-report",
          "Backup link: https://api.shareone.app/s/abc123",
          "Optional: add a password, watermark, or custom slug by replying with your preference."
        ]
      },
      {
        "input": "Change the watermark on https://shareone.app/s/abc123 to 'Internal Use Only'.",
        "output": [
          "Watermark updated successfully.",
          "Link: https://shareone.app/s/abc123",
          "Settings: watermark='Internal Use Only', comments=disabled, password=unchanged."
        ]
      },
      {
        "input": "Show me the comments on https://shareone.app/s/abc123.",
        "output": [
          "3 comments received.",
          "Comment 1: 'Can you add a section about pricing?' from user@example.com",
          "Comment 2: 'The chart on page 2 has wrong totals.' from reviewer@example.com",
          "Comment 3: 'Looks great overall.' from user@example.com"
        ]
      }
    ],
    "best_practices": [
      "Run check_api_key.js before any operation to confirm credentials are available and to detect the Sudowork environment.",
      "Wait for the user to reply 'agree' before publishing, since share links expose the content on the public web.",
      "Return the share_url exactly as the API provides it, including the backend_url when present, instead of constructing links manually."
    ],
    "anti_patterns": [
      "Do not call the system-wide shareone CLI found in PATH; always use the scripts in this skill directory.",
      "Do not pass --api-key while running in Sudowork mode; the Auth Proxy injects the credential automatically.",
      "Do not re-upload binary files through the page PUT endpoint; use shareone_upload.js for PDF, Word, PPTX, images, and zip files."
    ],
    "faq": [
      {
        "question": "How does the skill obtain a ShareOne API key?",
        "answer": "The skill checks process.env.SHAREONE_API_KEY and ~/.shareone_credentials. If neither is set, create_guest_key.js requests a temporary key from the ShareOne API and stores it locally."
      },
      {
        "question": "Can the skill be used without an API key?",
        "answer": "Public downloads work without authentication. All other operations, including upload, settings changes, and comment processing, require a valid ShareOne API key."
      },
      {
        "question": "What is the difference between upload_page.js and shareone_upload.js?",
        "answer": "upload_page.js publishes text pages such as HTML, Markdown, and TXT through the page API. shareone_upload.js publishes binary files such as PDF, Word, PPTX, images, and zip through the file upload API."
      },
      {
        "question": "How do I change the watermark on an existing share?",
        "answer": "Run update_share_settings.js with the share link and the --watermark flag. The source file is not downloaded or re-uploaded; only the metadata changes."
      },
      {
        "question": "Does the skill support comments and collaboration?",
        "answer": "Yes. The comments-view workflow reads comments on a shared page, and the comments-process workflow claims feedback, edits the source, and re-publishes the updated content."
      },
      {
        "question": "Which file types can be published?",
        "answer": "HTML, Markdown, TXT, PDF, Word (doc and docx), PowerPoint (ppt and pptx), PNG, JPG, GIF, and zip archives are all supported through the appropriate upload script."
      }
    ]
  },
  "file_structure": [
    {
      "name": "scripts",
      "type": "dir",
      "path": "scripts",
      "children": [
        {
          "name": "check_api_key.js",
          "type": "file",
          "path": "scripts/check_api_key.js",
          "lines": 31
        },
        {
          "name": "create_guest_key.js",
          "type": "file",
          "path": "scripts/create_guest_key.js",
          "lines": 45
        },
        {
          "name": "delete_api_key.js",
          "type": "file",
          "path": "scripts/delete_api_key.js",
          "lines": 24
        },
        {
          "name": "download_share.js",
          "type": "file",
          "path": "scripts/download_share.js",
          "lines": 123
        },
        {
          "name": "save_api_key.js",
          "type": "file",
          "path": "scripts/save_api_key.js",
          "lines": 32
        },
        {
          "name": "shareone_api_request.js",
          "type": "file",
          "path": "scripts/shareone_api_request.js",
          "lines": 66
        },
        {
          "name": "shareone_client.js",
          "type": "file",
          "path": "scripts/shareone_client.js",
          "lines": 290
        },
        {
          "name": "shareone_upload.js",
          "type": "file",
          "path": "scripts/shareone_upload.js",
          "lines": 205
        },
        {
          "name": "update_share_settings.js",
          "type": "file",
          "path": "scripts/update_share_settings.js",
          "lines": 196
        },
        {
          "name": "upload_page.js",
          "type": "file",
          "path": "scripts/upload_page.js",
          "lines": 117
        }
      ]
    },
    {
      "name": "workflows",
      "type": "dir",
      "path": "workflows",
      "children": [
        {
          "name": "comments-process.md",
          "type": "file",
          "path": "workflows/comments-process.md",
          "lines": 112
        },
        {
          "name": "comments-view.md",
          "type": "file",
          "path": "workflows/comments-view.md",
          "lines": 44
        },
        {
          "name": "delete-api-key.md",
          "type": "file",
          "path": "workflows/delete-api-key.md",
          "lines": 22
        },
        {
          "name": "download-file.md",
          "type": "file",
          "path": "workflows/download-file.md",
          "lines": 58
        },
        {
          "name": "environment-and-credentials.md",
          "type": "file",
          "path": "workflows/environment-and-credentials.md",
          "lines": 130
        },
        {
          "name": "publish-binary-file.md",
          "type": "file",
          "path": "workflows/publish-binary-file.md",
          "lines": 63
        },
        {
          "name": "publish-text-page.md",
          "type": "file",
          "path": "workflows/publish-text-page.md",
          "lines": 133
        },
        {
          "name": "result-and-errors.md",
          "type": "file",
          "path": "workflows/result-and-errors.md",
          "lines": 52
        },
        {
          "name": "update-share-settings.md",
          "type": "file",
          "path": "workflows/update-share-settings.md",
          "lines": 54
        }
      ]
    },
    {
      "name": "SKILL.md",
      "type": "file",
      "path": "SKILL.md",
      "lines": 138
    }
  ]
}