Загрузки и превью ссылок

import { Blok } from '@bloklabs/core';
import { supabaseStorage } from '@bloklabs/presets';

new Blok({
  holder: 'editor',
  uploader: supabaseStorage(supabase, { bucket: 'blok' }),
});

dotnet add package Blok.Server.AspNetCore

using Blok.Server.AspNetCore;

builder.Services.AddBlokServer(options =>
{
  options.StorageDirectory = "./blok-uploads";
  options.PublicUrl = "https://uploads.example.com/files";
  options.UnfurlDisabled = false;
});

var app = builder.Build();

app.MapBlokServer("/api/blok").RequireAuthorization();

import { Blok } from '@bloklabs/core';
import { fetchStorage } from '@bloklabs/presets';

new Blok({
  holder: 'editor',
  uploader: fetchStorage({ baseUrl: '/api/blok' }),
  tools: {
    bookmark: { config: { endpoint: '/api/blok/unfurl' } },
  },
});

docker run \
  --network host \
  --mount type=volume,source=blok-server-data,target=/data \
  ghcr.io/jackuait/blok-server \
  --listen 127.0.0.1:4000 \
  --auth proxy \
  --allow-origin https://myapp.com \
  --storage-dir /data \
  --public-url https://uploads.myapp.com/files

import { createProxyMiddleware } from 'http-proxy-middleware';

// Everything under /api/blok goes to the service. requireLogin is your own
// existing check — the service trusts whatever reaches it, so this line is
// what decides who may upload.
app.use(
  '/api/blok',
  requireLogin,
  createProxyMiddleware({ target: 'http://127.0.0.1:4000', pathRewrite: { '^/api/blok': '' } }),
);

import { Blok } from '@bloklabs/core';
import { fetchStorage } from '@bloklabs/presets';

new Blok({
  holder: 'editor',
  uploader: fetchStorage({ baseUrl: '/api/blok' }),
  tools: {
    bookmark: { config: { endpoint: '/api/blok/unfurl' } },
  },
});

docker run \
  -p 127.0.0.1:4000:4000 \
  --mount type=volume,source=blok-server-data,target=/data \
  -e BLOK_SECRET \
  ghcr.io/jackuait/blok-server \
  --listen 0.0.0.0:4000 \
  --auth ticket \
  --allow-origin https://myapp.com \
  --storage-dir /data \
  --public-url https://blok.myapp.com/files

// app/api/blok-ticket/route.ts
import { createHmac } from 'node:crypto';

const b64 = (value: string) => Buffer.from(value).toString('base64url');

export async function GET() {
  const session = await getSession();

  if (!session) {
    return new Response('Not signed in', { status: 401 });
  }

  // A standard JWT. Every language has a one-line library for this; it is
  // spelled out here so you can see there is no magic in it.
  const head = b64(JSON.stringify({ alg: 'HS256', typ: 'JWT' }));
  const body = b64(
    JSON.stringify({
      user: session.userId,
      write: true,
      exp: Math.floor(Date.now() / 1000) + 60 * 60,
    }),
  );
  const signature = createHmac('sha256', process.env.BLOK_SECRET ?? '')
    .update(`${head}.${body}`)
    .digest('base64url');

  return Response.json({ ticket: `${head}.${body}.${signature}` });
}

import { Blok } from '@bloklabs/core';
import { fetchStorage } from '@bloklabs/presets';

const SERVICE = 'https://blok.myapp.com';

// Called before every upload, so an expired pass is replaced without a reload.
const authHeaders = async () => {
  const { ticket } = await fetch('/api/blok-ticket').then((r) => r.json());

  return { Authorization: `Bearer ${ticket}` };
};

new Blok({
  holder: 'editor',
  uploader: fetchStorage({ baseUrl: SERVICE, headers: authHeaders }),
  tools: {
    bookmark: { config: { endpoint: `${SERVICE}/unfurl`, headers: await authHeaders() } },
  },
});