@synopackageland/cli 0.3.10 → 0.4.1

package/dist/mock-broker/files.js

@@ -1,408 +0,0 @@
-import { copyFileSync, createReadStream, existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { dirname, join, posix } from "node:path";
-import { normalizeLogicalPath, parentAndName, PathValidationError } from "./path.js";
-export class FileStoreError extends Error {
-    code;
-    status;
-    constructor(code, status, message) {
-        super(message);
-        this.name = "FileStoreError";
-        this.code = code;
-        this.status = status;
-    }
-}
-const ERROR_MESSAGES = {
-    NOT_FOUND: "找不到這個路徑。",
-    CONFLICT: "目標已存在。",
-    INVALID_PATH: "路徑不合法。",
-    TRASH_UNAVAILABLE: "目標沒有可用的 trash／recycle bin，檔案未被刪除。",
-};
-function notFound() {
-    throw new FileStoreError("NOT_FOUND", 404, ERROR_MESSAGES.NOT_FOUND);
-}
-function conflict() {
-    throw new FileStoreError("CONFLICT", 409, ERROR_MESSAGES.CONFLICT);
-}
-function invalidPath() {
-    throw new FileStoreError("INVALID_PATH", 400, ERROR_MESSAGES.INVALID_PATH);
-}
-function trashUnavailable() {
-    throw new FileStoreError("TRASH_UNAVAILABLE", 409, ERROR_MESSAGES.TRASH_UNAVAILABLE);
-}
-function seedDefaultTree() {
-    const root = { type: "directory", children: new Map() };
-    const home = ensureDirNode(root, "/home");
-    home.children.set("docs", { type: "directory", children: new Map() });
-    home.children.set("notes", { type: "directory", children: new Map() });
-    home.children.set("readme.txt", {
-        type: "file",
-        content: Buffer.alloc(42),
-    });
-    return root;
-}
-function ensureDirNode(root, path) {
-    let node = root;
-    for (const part of path.split("/").filter(Boolean)) {
-        node.children ??= new Map();
-        let child = node.children.get(part);
-        if (!child) {
-            child = { type: "directory", children: new Map() };
-            node.children.set(part, child);
-        }
-        if (child.type !== "directory") {
-            conflict();
-        }
-        node = child;
-    }
-    return node;
-}
-function getNode(root, path) {
-    if (path === "/") {
-        return root;
-    }
-    let node = root;
-    for (const part of path.split("/").filter(Boolean)) {
-        node = node?.children?.get(part);
-        if (!node) {
-            return undefined;
-        }
-    }
-    return node;
-}
-function toItem(path, node) {
-    const name = path.split("/").filter(Boolean).at(-1) ?? path;
-    if (node.type === "directory") {
-        return { name, type: "directory", path };
-    }
-    return {
-        name,
-        type: "file",
-        path,
-        size: node.content?.length ?? 0,
-    };
-}
-function mapLogicalToAbsolute(logicalPath, filesRoot) {
-    const trimmed = logicalPath.replace(/\\/g, "/").replace(/\/+$/, "") || "/";
-    if (trimmed === "/") {
-        return filesRoot;
-    }
-    const normalized = normalizeLogicalPath(logicalPath);
-    const relative = normalized.replace(/^\//, "");
-    return join(filesRoot, relative);
-}
-export class MockFileStore {
-    filesRoot;
-    recycleBinDisabled;
-    treeRoot;
-    constructor(options = {}) {
-        this.filesRoot = options.filesRoot;
-        this.recycleBinDisabled = options.recycleBinDisabled ?? false;
-        this.treeRoot = seedDefaultTree();
-    }
-    list(rawPath) {
-        const path = this.resolveListPath(rawPath);
-        if (this.filesRoot) {
-            return this.listMapped(path);
-        }
-        return this.listMemory(path);
-    }
-    stat(rawPath) {
-        const path = this.resolveOperationPath(rawPath);
-        if (this.filesRoot) {
-            return this.statMapped(path);
-        }
-        return this.statMemory(path);
-    }
-    download(rawPath, range) {
-        const path = this.resolveOperationPath(rawPath);
-        if (this.filesRoot) {
-            return this.downloadMapped(path, range);
-        }
-        return this.downloadMemory(path, range);
-    }
-    upload(rawPath, body, overwrite = false) {
-        const path = this.resolveOperationPath(rawPath);
-        if (this.filesRoot) {
-            this.uploadMapped(path, body, overwrite);
-            return;
-        }
-        this.uploadMemory(path, body, overwrite);
-    }
-    mkdir(rawPath) {
-        const path = this.resolveOperationPath(rawPath);
-        if (this.filesRoot) {
-            this.mkdirMapped(path);
-            return;
-        }
-        this.mkdirMemory(path);
-    }
-    rename(rawPath, rawTo, overwrite = false) {
-        this.move(rawPath, rawTo, overwrite);
-    }
-    move(rawPath, rawTo, overwrite = false) {
-        const path = this.resolveOperationPath(rawPath);
-        const to = this.resolveOperationPath(rawTo);
-        if (this.filesRoot) {
-            this.moveMapped(path, to, overwrite);
-            return;
-        }
-        this.moveMemory(path, to, overwrite);
-    }
-    copy(rawPath, rawTo, overwrite = false) {
-        const path = this.resolveOperationPath(rawPath);
-        const to = this.resolveOperationPath(rawTo);
-        if (this.filesRoot) {
-            this.copyMapped(path, to, overwrite);
-            return;
-        }
-        this.copyMemory(path, to, overwrite);
-    }
-    trash(rawPath) {
-        if (this.recycleBinDisabled) {
-            trashUnavailable();
-        }
-        const path = this.resolveOperationPath(rawPath);
-        if (this.filesRoot) {
-            this.trashMapped(path);
-            return;
-        }
-        this.trashMemory(path);
-    }
-    resolveListPath(rawPath) {
-        const trimmed = rawPath.trim();
-        if (trimmed === "/" || trimmed === "") {
-            return "/";
-        }
-        try {
-            return normalizeLogicalPath(trimmed);
-        }
-        catch (error) {
-            if (error instanceof PathValidationError) {
-                invalidPath();
-            }
-            throw error;
-        }
-    }
-    resolveOperationPath(rawPath) {
-        try {
-            return normalizeLogicalPath(rawPath);
-        }
-        catch (error) {
-            if (error instanceof PathValidationError) {
-                invalidPath();
-            }
-            throw error;
-        }
-    }
-    listMemory(path) {
-        const node = getNode(this.treeRoot, path);
-        if (!node || node.type !== "directory") {
-            return [];
-        }
-        const items = [];
-        for (const [name, child] of node.children ?? []) {
-            items.push(toItem(posix.join(path, name), child));
-        }
-        return items;
-    }
-    statMemory(path) {
-        const node = getNode(this.treeRoot, path);
-        if (!node) {
-            notFound();
-        }
-        return toItem(path, node);
-    }
-    downloadMemory(path, range) {
-        const node = getNode(this.treeRoot, path);
-        if (!node || node.type !== "file") {
-            notFound();
-        }
-        const original = node.content ?? Buffer.alloc(0);
-        if (!range) {
-            return { buffer: original, size: original.length, totalSize: original.length };
-        }
-        const end = range.end ?? original.length - 1;
-        const slice = original.subarray(range.start, end + 1);
-        return { buffer: slice, size: slice.length, totalSize: original.length };
-    }
-    uploadMemory(path, body, overwrite) {
-        if (getNode(this.treeRoot, path) && !overwrite) {
-            conflict();
-        }
-        const { parent, name } = parentAndName(path);
-        const dir = ensureDirNode(this.treeRoot, parent);
-        dir.children ??= new Map();
-        dir.children.set(name, { type: "file", content: Buffer.from(body) });
-    }
-    mkdirMemory(path) {
-        if (getNode(this.treeRoot, path)) {
-            conflict();
-        }
-        ensureDirNode(this.treeRoot, path);
-    }
-    moveMemory(path, to, overwrite) {
-        const node = getNode(this.treeRoot, path);
-        if (!node) {
-            notFound();
-        }
-        if (getNode(this.treeRoot, to) && !overwrite) {
-            conflict();
-        }
-        const from = parentAndName(path);
-        const dest = parentAndName(to);
-        const fromDir = getNode(this.treeRoot, from.parent);
-        if (!fromDir?.children?.has(from.name)) {
-            notFound();
-        }
-        fromDir.children.delete(from.name);
-        const toDir = ensureDirNode(this.treeRoot, dest.parent);
-        toDir.children ??= new Map();
-        toDir.children.set(dest.name, node);
-    }
-    copyMemory(path, to, overwrite) {
-        const node = getNode(this.treeRoot, path);
-        if (!node) {
-            notFound();
-        }
-        if (getNode(this.treeRoot, to) && !overwrite) {
-            conflict();
-        }
-        const dest = parentAndName(to);
-        const toDir = ensureDirNode(this.treeRoot, dest.parent);
-        toDir.children ??= new Map();
-        toDir.children.set(dest.name, cloneNode(node));
-    }
-    trashMemory(path) {
-        const node = getNode(this.treeRoot, path);
-        if (!node) {
-            notFound();
-        }
-        const { parent, name } = parentAndName(path);
-        const parentNode = getNode(this.treeRoot, parent);
-        parentNode?.children?.delete(name);
-    }
-    listMapped(path) {
-        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
-        let entries;
-        try {
-            entries = readdirSync(absolute);
-        }
-        catch {
-            return [];
-        }
-        const normalized = path.replace(/\/+$/, "") || "/";
-        return entries.map((name) => {
-            const childAbsolute = join(absolute, name);
-            const childLogical = posix.join(normalized === "/" ? "" : normalized, name);
-            const displayPath = childLogical.startsWith("/") ? childLogical : `/${childLogical}`;
-            const stat = statSync(childAbsolute);
-            if (stat.isDirectory()) {
-                return { name, type: "directory", path: displayPath };
-            }
-            return {
-                name,
-                type: "file",
-                path: displayPath,
-                size: stat.size,
-            };
-        });
-    }
-    statMapped(path) {
-        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
-        if (!existsSync(absolute)) {
-            notFound();
-        }
-        const stat = statSync(absolute);
-        const name = path.split("/").filter(Boolean).at(-1) ?? path;
-        if (stat.isDirectory()) {
-            return { name, type: "directory", path };
-        }
-        return { name, type: "file", path, size: stat.size };
-    }
-    downloadMapped(path, range) {
-        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
-        if (!existsSync(absolute)) {
-            notFound();
-        }
-        const stat = statSync(absolute);
-        if (!stat.isFile()) {
-            notFound();
-        }
-        const totalSize = stat.size;
-        if (!range) {
-            return {
-                stream: createReadStream(absolute),
-                size: totalSize,
-                totalSize,
-            };
-        }
-        const end = range.end ?? totalSize - 1;
-        const size = end - range.start + 1;
-        return {
-            stream: createReadStream(absolute, { start: range.start, end }),
-            size,
-            totalSize,
-        };
-    }
-    uploadMapped(path, body, overwrite) {
-        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
-        if (existsSync(absolute) && !overwrite) {
-            conflict();
-        }
-        mkdirSync(dirname(absolute), { recursive: true });
-        writeFileSync(absolute, body);
-    }
-    mkdirMapped(path) {
-        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
-        if (existsSync(absolute)) {
-            conflict();
-        }
-        mkdirSync(absolute, { recursive: true });
-    }
-    moveMapped(path, to, overwrite) {
-        const fromAbsolute = mapLogicalToAbsolute(path, this.filesRoot);
-        const toAbsolute = mapLogicalToAbsolute(to, this.filesRoot);
-        if (!existsSync(fromAbsolute)) {
-            notFound();
-        }
-        if (existsSync(toAbsolute) && !overwrite) {
-            conflict();
-        }
-        mkdirSync(dirname(toAbsolute), { recursive: true });
-        renameSync(fromAbsolute, toAbsolute);
-    }
-    copyMapped(path, to, overwrite) {
-        const fromAbsolute = mapLogicalToAbsolute(path, this.filesRoot);
-        const toAbsolute = mapLogicalToAbsolute(to, this.filesRoot);
-        if (!existsSync(fromAbsolute)) {
-            notFound();
-        }
-        if (existsSync(toAbsolute) && !overwrite) {
-            conflict();
-        }
-        mkdirSync(dirname(toAbsolute), { recursive: true });
-        copyFileSync(fromAbsolute, toAbsolute);
-    }
-    trashMapped(path) {
-        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
-        if (!existsSync(absolute)) {
-            notFound();
-        }
-        rmSync(absolute, { recursive: true, force: true });
-    }
-}
-function cloneNode(node) {
-    if (node.type === "file") {
-        return { type: "file", content: node.content ? Buffer.from(node.content) : Buffer.alloc(0) };
-    }
-    const children = new Map();
-    for (const [name, child] of node.children ?? []) {
-        children.set(name, cloneNode(child));
-    }
-    return { type: "directory", children };
-}
-/** @deprecated Use MockFileStore.list instead */
-export function listFakeFiles(path, filesRoot) {
-    const store = new MockFileStore({ filesRoot });
-    return store.list(path);
-}

package/dist/mock-broker/oidc.d.ts

@@ -1,31 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-export declare const MOCK_OIDC_CLIENT_SECRET = "mock-oidc-secret";
-export declare const MOCK_OIDC_REDIRECT_PATH = "/api/auth/sso_callback";
-export declare const MOCK_OIDC_KID_PREFIX = "oidc-";
-export interface MockOidcUser {
-    subject: string;
-    username: string;
-    displayName: string;
-}
-export interface MockOidcOptions {
-    clientId?: string;
-    clientSecret?: string;
-    redirectUri?: string;
-}
-interface AuthCode {
-    code: string;
-    clientId: string;
-    redirectUri: string;
-    consumed: boolean;
-}
-export interface MockOidcContext {
-    packageId: string;
-    clientId: string;
-    clientSecret: string;
-    redirectUri: string;
-    user: MockOidcUser;
-    codes: Map<string, AuthCode>;
-}
-export declare function createMockOidcContext(packageId: string, user: MockOidcUser, options?: MockOidcOptions): MockOidcContext;
-export declare function handleMockOidc(req: IncomingMessage, res: ServerResponse, url: URL, ctx: MockOidcContext): Promise<boolean>;
-export {};

package/dist/mock-broker/oidc.js

@@ -1,161 +0,0 @@
-import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { exportJWK, generateKeyPair, SignJWT } from "jose";
-export const MOCK_OIDC_CLIENT_SECRET = "mock-oidc-secret";
-export const MOCK_OIDC_REDIRECT_PATH = "/api/auth/sso_callback";
-export const MOCK_OIDC_KID_PREFIX = "oidc-";
-let oidcKeyPromise = null;
-async function oidcKeys() {
-    if (!oidcKeyPromise) {
-        oidcKeyPromise = generateKeyPair("RS256");
-    }
-    return oidcKeyPromise;
-}
-function sendJson(res, status, body) {
-    res.statusCode = status;
-    res.setHeader("content-type", "application/json; charset=utf-8");
-    res.end(JSON.stringify(body));
-}
-function sendOAuthError(res, status, error) {
-    sendJson(res, status, { error });
-}
-function secretsEqual(left, right) {
-    return left.length === right.length && left === right;
-}
-function issuerFromRequest(req) {
-    const host = req.headers.host ?? "127.0.0.1";
-    return `http://${host}/oidc`;
-}
-function discovery(issuer) {
-    const base = issuer.replace(/\/$/, "");
-    return {
-        issuer: base,
-        authorization_endpoint: `${base}/authorize`,
-        token_endpoint: `${base}/token`,
-        jwks_uri: `${base}/jwks`,
-        response_types_supported: ["code"],
-        grant_types_supported: ["authorization_code"],
-        subject_types_supported: ["public"],
-        id_token_signing_alg_values_supported: ["RS256"],
-        token_endpoint_auth_methods_supported: ["client_secret_post"],
-        scopes_supported: ["openid"],
-        claims_supported: ["iss", "sub", "aud", "exp", "iat", "preferred_username", "name"],
-    };
-}
-async function oidcKid() {
-    const { publicKey } = await oidcKeys();
-    const jwk = await exportJWK(publicKey);
-    return `${MOCK_OIDC_KID_PREFIX}${createHash("sha256")
-        .update(JSON.stringify(jwk))
-        .digest("hex")
-        .slice(0, 16)}`;
-}
-async function issueIdToken(issuer, clientId, user) {
-    const { privateKey } = await oidcKeys();
-    const kid = await oidcKid();
-    return new SignJWT({
-        preferred_username: user.username,
-        name: user.username,
-        mock: true,
-    })
-        .setProtectedHeader({ alg: "RS256", kid })
-        .setIssuer(issuer)
-        .setAudience(clientId)
-        .setSubject(user.subject)
-        .setIssuedAt()
-        .setExpirationTime("15m")
-        .sign(privateKey);
-}
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
-        req.on("error", reject);
-    });
-}
-export function createMockOidcContext(packageId, user, options) {
-    return {
-        packageId,
-        clientId: options?.clientId ?? packageId,
-        clientSecret: options?.clientSecret ?? MOCK_OIDC_CLIENT_SECRET,
-        redirectUri: options?.redirectUri ?? `http://127.0.0.1${MOCK_OIDC_REDIRECT_PATH}`,
-        user,
-        codes: new Map(),
-    };
-}
-export async function handleMockOidc(req, res, url, ctx) {
-    const pathname = (url.pathname.replace(/\/$/, "") || "/");
-    if (!pathname.startsWith("/oidc")) {
-        return false;
-    }
-    const issuer = issuerFromRequest(req);
-    if (req.method === "GET" && pathname === "/oidc/.well-known/openid-configuration") {
-        sendJson(res, 200, discovery(issuer));
-        return true;
-    }
-    if (req.method === "GET" && pathname === "/oidc/jwks") {
-        const { publicKey } = await oidcKeys();
-        const jwk = await exportJWK(publicKey);
-        jwk.alg = "RS256";
-        jwk.use = "sig";
-        jwk.kid = await oidcKid();
-        sendJson(res, 200, { keys: [jwk] });
-        return true;
-    }
-    if (req.method === "GET" && pathname === "/oidc/authorize") {
-        const clientId = url.searchParams.get("client_id") ?? "";
-        const redirectUri = url.searchParams.get("redirect_uri") ?? "";
-        const responseType = url.searchParams.get("response_type") ?? "";
-        const state = url.searchParams.get("state");
-        if (clientId !== ctx.clientId || redirectUri !== ctx.redirectUri) {
-            sendOAuthError(res, 400, "invalid_request");
-            return true;
-        }
-        if (responseType !== "code") {
-            sendOAuthError(res, 400, "unsupported_response_type");
-            return true;
-        }
-        const code = randomUUID();
-        ctx.codes.set(code, { code, clientId, redirectUri, consumed: false });
-        const location = new URL(redirectUri);
-        location.searchParams.set("code", code);
-        if (state) {
-            location.searchParams.set("state", state);
-        }
-        res.statusCode = 302;
-        res.setHeader("location", location.toString());
-        res.end();
-        return true;
-    }
-    if (req.method === "POST" && pathname === "/oidc/token") {
-        const text = await readBody(req);
-        const body = Object.fromEntries(new URLSearchParams(text).entries());
-        if (body.client_id !== ctx.clientId || !secretsEqual(body.client_secret ?? "", ctx.clientSecret)) {
-            sendOAuthError(res, 401, "invalid_client");
-            return true;
-        }
-        if (body.grant_type !== "authorization_code") {
-            sendOAuthError(res, 400, "unsupported_grant_type");
-            return true;
-        }
-        const record = ctx.codes.get(body.code ?? "");
-        if (!record ||
-            record.consumed ||
-            record.clientId !== body.client_id ||
-            record.redirectUri !== (body.redirect_uri ?? "")) {
-            sendOAuthError(res, 400, "invalid_grant");
-            return true;
-        }
-        record.consumed = true;
-        const idToken = await issueIdToken(issuer, ctx.clientId, ctx.user);
-        sendJson(res, 200, {
-            id_token: idToken,
-            access_token: randomBytes(24).toString("base64url"),
-            token_type: "Bearer",
-            expires_in: 15 * 60,
-        });
-        return true;
-    }
-    sendOAuthError(res, 404, "invalid_request");
-    return true;
-}

package/dist/mock-broker/path.d.ts

@@ -1,9 +0,0 @@
-export declare class PathValidationError extends Error {
-    readonly code: "INVALID_PATH";
-    constructor();
-}
-export declare function normalizeLogicalPath(raw: string): string;
-export declare function parentAndName(logicalPath: string): {
-    parent: string;
-    name: string;
-};

package/dist/mock-broker/path.js

@@ -1,50 +0,0 @@
-export class PathValidationError extends Error {
-    code = "INVALID_PATH";
-    constructor() {
-        super("路徑不合法。");
-        this.name = "PathValidationError";
-    }
-}
-const MAX_PATH_LENGTH = 4096;
-export function normalizeLogicalPath(raw) {
-    if (typeof raw !== "string" || raw.length === 0) {
-        throw new PathValidationError();
-    }
-    if (raw.includes("\0") || raw.length > MAX_PATH_LENGTH) {
-        throw new PathValidationError();
-    }
-    const unified = raw.replace(/\\/g, "/");
-    if (!unified.startsWith("/")) {
-        throw new PathValidationError();
-    }
-    if (/^\/volume\d+/i.test(unified) ||
-        unified.startsWith("/volumeUSB") ||
-        unified.startsWith("/volumeSATA")) {
-        throw new PathValidationError();
-    }
-    const parts = [];
-    for (const segment of unified.split("/")) {
-        if (segment === "" || segment === ".") {
-            continue;
-        }
-        if (segment === "..") {
-            throw new PathValidationError();
-        }
-        parts.push(segment);
-    }
-    if (parts.length === 0) {
-        throw new PathValidationError();
-    }
-    return `/${parts.join("/")}`;
-}
-export function parentAndName(logicalPath) {
-    const normalized = normalizeLogicalPath(logicalPath);
-    const idx = normalized.lastIndexOf("/");
-    if (idx <= 0) {
-        throw new PathValidationError();
-    }
-    return {
-        parent: normalized.slice(0, idx) || "/",
-        name: normalized.slice(idx + 1),
-    };
-}

package/dist/mock-broker/server.d.ts

@@ -1,19 +0,0 @@
-import { type Server } from "node:http";
-import type { SynologyUser } from "@synopackageland/dev-sdk/node";
-import { type MockOidcOptions } from "./oidc.js";
-export declare const FAKE_USER: SynologyUser;
-export interface MockBrokerOptions {
-    packageId: string;
-    filesRoot?: string;
-    recycleBinDisabled?: boolean;
-    port?: number;
-    oidc?: MockOidcOptions;
-}
-export interface MockBrokerHandle {
-    baseUrl: string;
-    jwksUrl: string;
-    packageId: string;
-    server: Server;
-    close(): Promise<void>;
-}
-export declare function startMockBroker(options: MockBrokerOptions): Promise<MockBrokerHandle>;