@skillcdn/console 0.4.1 → 0.4.3

package/src/data.ts

@@ -39,12 +39,14 @@ import {
   type RestPerson,
   type RestPersonPatch,
   type RestPersonWork,
+  type RestPlugin,
   type RestProject,
   type RestProjectInput,
   type RestProjectPatch,
   type RestProjectRules,
   type RestRules,
   type RestRulesInput,
+  type RestRulesPlugin,
   type RestRun,
   type RestSkills,
   type RestTask,
@@ -123,7 +125,8 @@ export interface ConsoleActions {
     page: { readonly limit: number; readonly offset: number },
     signal?: AbortSignal,
   ): Promise<RestGoals>;
-  raiseDecision(input: RestDecisionInput): Promise<RestDecision>;
+  /** Raises a decision in the project; with `files`, the files put on it (ADR-0055). */
+  raiseDecision(input: RestDecisionInput, files?: readonly FileUpload[]): Promise<RestDecision>;
   answerDecision(id: string, input: RestAnswerInput): Promise<RestDecision>;
   /** Answers a decision of any project the person may see, by its project's key: for the person's own page of decisions (ADR-0042). */
   answerDecisionIn(projectKey: string, id: string, input: RestAnswerInput): Promise<RestDecision>;
@@ -198,6 +201,8 @@ export interface ConsoleActions {
   connectRequest(code: string, signal?: AbortSignal): Promise<RestConnectRequest>;
   approveConnection(code: string, input: RestTokenInput): Promise<RestConnectRequest>;
   denyConnection(code: string): Promise<void>;
+  /** Reads the plugins again: after one was enabled, configured or disabled on the settings. */
+  refreshPlugins(): Promise<void>;
   /** Another person's plate: for an administrator, or an owner of a project they are in. */
   personWork(personId: string, signal?: AbortSignal): Promise<RestPersonWork>;
   /** The tokens of another person, and the way to take one away: for an administrator. */
@@ -223,6 +228,8 @@ export interface ConsoleData {
   readonly organization: RestOrganization | null;
   /** The categories tasks are sorted into, by name. */
   readonly categories: readonly RestCategory[];
+  /** The plugins the person may know of (docs/specs/plugins.md), by key: the enabled ones, every one for an administrator. */
+  readonly plugins: readonly RestPlugin[];
   /** The tokens of whoever is signed in, newest first. */
   readonly tokens: readonly RestToken[];
   /** The project the page is on, once loaded; `undefined` while loading, or when the page is on none. */
@@ -245,6 +252,8 @@ export interface ConsoleData {
   readonly members: readonly RestMember[];
   /** The project's skills, as the console answered; `undefined` until it has. */
   readonly skills: RestSkills | undefined;
+  /** The plugins bound to the project that the person holds a role in, as the rules name them. */
+  readonly projectPlugins: readonly RestRulesPlugin[];
   readonly actions: ConsoleActions;
   /** Asks everything again, from who is signed in on. */
   reload(): void;
@@ -354,6 +363,7 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
   const [listed, setListed] = useState<readonly RestListing[]>([]);
   const [organization, setOrganization] = useState<RestOrganization | null>(null);
   const [categories, setCategories] = useState<readonly RestCategory[]>([]);
+  const [plugins, setPlugins] = useState<readonly RestPlugin[]>([]);
   const [tokens, setTokens] = useState<readonly RestToken[]>([]);
   const [project, setProject] = useState<RestProject | undefined>(undefined);
   const [projectLoaded, setProjectLoaded] = useState(false);
@@ -366,19 +376,36 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
   const [events, setEvents] = useState<readonly RestEvent[]>([]);
   const [members, setMembers] = useState<readonly RestMember[]>([]);
   const [skills, setSkills] = useState<RestSkills | undefined>(undefined);
+  const [projectPlugins, setProjectPlugins] = useState<readonly RestRulesPlugin[]>([]);
   const [generation, setGeneration] = useState(0);
   const lastEvent = useRef(0);
   const signedIn = me?.person !== null && me !== undefined;
 
   const reload = useCallback(() => setGeneration((current) => current + 1), []);
 
+  /**
+   * Asks again who is signed in, for what moves with the board: the decisions waiting for the
+   * person, said beside My decisions. What fails stays as it was.
+   */
+  const refreshMe = useCallback(
+    async (signal?: AbortSignal) => {
+      const answer = await client.me(signal);
+      if (signal?.aborted !== true) {
+        setMe(answer);
+      }
+    },
+    [client],
+  );
+
   /** Loads the workspace's lists again. What fails stays as it was. */
   const refreshWorkspace = useCallback(
     async (signal?: AbortSignal) => {
-      const [nextProjects, nextPeople, nextCategories] = await Promise.all([
+      const [nextProjects, nextPeople, nextCategories, nextPlugins] = await Promise.all([
         client.projects(signal),
         client.people(signal),
         client.categories(signal),
+        // A console without plugins answers none; one older than them answers nothing, which is none too.
+        client.plugins(signal).catch(() => ({ items: [], sql: false })),
       ]);
       if (signal?.aborted === true) {
         return;
@@ -388,6 +415,7 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
       setListed(nextPeople.listed);
       setOrganization(nextPeople.organization);
       setCategories(nextCategories.items);
+      setPlugins(nextPlugins.items);
     },
     [client],
   );
@@ -399,7 +427,7 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
         return;
       }
       const scope = client.project(projectKey);
-      const [nextProject, nextTasks, nextDecisions, nextGoals, nextRuns, nextMembers] =
+      const [nextProject, nextTasks, nextDecisions, nextGoals, nextRuns, nextMembers, nextPlugins] =
         await Promise.all([
           scope.get(signal),
           readTasks(scope, signal),
@@ -407,6 +435,11 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
           readGoals(scope, signal),
           scope.runs(undefined, signal),
           scope.members(signal),
+          // The plugins bound to the project come with its rules; a console older than them names none.
+          scope
+            .rules(signal)
+            .then((rules) => rules.plugins ?? [])
+            .catch((): readonly RestRulesPlugin[] => []),
         ]);
       if (signal?.aborted === true) {
         return;
@@ -417,6 +450,7 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
       setGoals(nextGoals.items);
       setRuns(nextRuns.items);
       setMembers(nextMembers.items);
+      setProjectPlugins(nextPlugins);
     },
     [client, projectKey],
   );
@@ -480,6 +514,7 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
     setEvents([]);
     setMembers([]);
     setSkills(undefined);
+    setProjectPlugins([]);
     setLive(false);
     if (projectKey === undefined || !signedIn) {
       return;
@@ -551,6 +586,11 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
           if (event.kind.startsWith("project.")) {
             refreshWorkspace(signal).catch(() => undefined);
           }
+          // A decision raised or answered here may be one of the person's own: the count beside
+          // My decisions follows it.
+          if (event.kind.startsWith("decision.")) {
+            refreshMe(signal).catch(() => undefined);
+          }
         }, RELOAD_DELAY_MS);
       };
       for (const kind of EVENT_KINDS) {
@@ -564,7 +604,7 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
       source?.close();
       setLive(false);
     };
-  }, [client, projectKey, signedIn, generation, refreshProject, refreshWorkspace]);
+  }, [client, projectKey, signedIn, generation, refreshProject, refreshWorkspace, refreshMe]);
 
   const actions = useMemo<ConsoleActions>(() => {
     /** The project the page is on, for an action that needs one. */
@@ -664,16 +704,19 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
         scope().tasks({ archived: false, ...searchWordsOf(query), ...page }, signal),
       findGoals: (query, page, signal) =>
         scope().goals({ open: true, ...searchWordsOf(query), ...page }, signal),
-      async raiseDecision(input) {
-        const decision = await scope().raiseDecision(input);
-        await refreshProject();
+      async raiseDecision(input, files) {
+        const decision = await scope().raiseDecision(input, files);
+        await Promise.all([refreshProject(), refreshMe().catch(() => undefined)]);
+        return decision;
+      },
+      async answerDecisionIn(projectKey, id, input) {
+        const decision = await client.project(projectKey).answerDecision(id, input);
+        await refreshMe().catch(() => undefined);
         return decision;
       },
-      answerDecisionIn: (projectKey, id, input) =>
-        client.project(projectKey).answerDecision(id, input),
       async answerDecision(id, input) {
         const decision = await scope().answerDecision(id, input);
-        await refreshProject();
+        await Promise.all([refreshProject(), refreshMe().catch(() => undefined)]);
         return decision;
       },
       async updateDecision(id, patch) {
@@ -766,6 +809,9 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
       },
       cancelWorkspacePackTokenConnection: () => client.cancelWorkspacePackTokenConnection(),
       findPerson: (login, signal) => client.findPerson(login, signal),
+      async refreshPlugins() {
+        setPlugins((await client.plugins()).items);
+      },
       async abandonRun(id) {
         const run = await scope().endRun(id, { status: "abandoned" });
         await refreshProject();
@@ -811,7 +857,7 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
         setLoaded(false);
       },
     };
-  }, [client, projectKey, refreshProject, refreshWorkspace]);
+  }, [client, projectKey, refreshProject, refreshWorkspace, refreshMe]);
 
   return {
     me,
@@ -822,6 +868,7 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
     listed,
     organization,
     categories,
+    plugins,
     tokens,
     project,
     projectLoaded,
@@ -834,6 +881,7 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
     events,
     members,
     skills,
+    projectPlugins,
     actions,
     reload,
   };

package/src/i18n/en.ts

@@ -29,6 +29,15 @@ export const en = {
   label: "English",
 
   vocabulary: {
+    /** The states of a plugin (docs/specs/plugins.md, "Lifecycle"). */
+    pluginState: {
+      installed: "Installed",
+      enabled: "Enabled",
+      needs_consent: "Needs consent",
+      disabled: "Disabled",
+      failed: "Failed",
+      orphaned: "Orphaned",
+    } as Record<string, string>,
     state: {
       idea: "Idea",
       ready: "Ready",
@@ -143,6 +152,138 @@ export const en = {
     skills: "Skills",
     members: "Members",
     settings: "Settings",
+    plugins: "Plugins",
+    /** The groups of tabs the console knows (docs/specs/plugins.md, "Tabs, sub-tabs and addresses"). */
+    pluginGroups: {
+      people: "People",
+      customers: "Customers",
+      money: "Money",
+      operations: "Operations",
+      marketing: "Marketing",
+      engineering: "Engineering",
+      reports: "Reports",
+    } as Record<string, string>,
+  },
+
+  plugins: {
+    frame: (name: string) => `${name}, a plugin's page`,
+    noPage: {
+      title: "Nothing here",
+      body: "This plugin has no page you may see, or it is not on this project.",
+    },
+    settings: {
+      title: "Plugins",
+      empty: { title: "No plugins", body: "None is installed in this console's image." },
+      none: "The console has no plugins directory: none can be installed.",
+      about: "About",
+      problems: "Why it cannot run",
+      nothing: "None",
+      capabilities: "Capabilities",
+      board: "Board project",
+      boardHint: "Where its decisions, tasks and pages go.",
+      boardNone: "None",
+      boardCreate: "A new project",
+      boardChoose: "An existing project",
+      boardKey: "Key",
+      boardName: "Name",
+      boardDescription: "Description",
+      projects: "Projects",
+      projectsAll: "Every project",
+      projectsSome: "Some projects",
+      settingsForm: "Settings",
+      secretSet: (when: string) => `Set ${when}`,
+      secretUnset: "Not set",
+      secretNew: "New value",
+      enable: "Enable",
+      disable: "Disable",
+      roles: "Roles",
+      rolesNone: "No roles: every member may use it.",
+      roleDefault: "Default",
+      everyMember: "Every member",
+      grantEveryone: "Everyone",
+      grantMembersOf: (project: string) => `Members of ${project}`,
+      grantPeople: "People",
+      grantProjects: "Members of a project",
+      grantWhom: "Grant to…",
+      grant: "Grant",
+      revoke: "Revoke",
+      events: "What happened",
+      noEvents: "Nothing yet.",
+      data: "Data",
+      export: "Export",
+      exportHint: "Its records and their versions, as JSON Lines.",
+      exportLink: "Download",
+      purge: "Purge",
+      purgeHint:
+        "Removes its records, files, grants and secrets from the console. What it put on the board stays.",
+      purgeDisabledFirst: "Disable it first.",
+      purgeConfirm: (key: string) => `Type ${key}`,
+      purged: "Purged.",
+      agentNote: "For agents",
+      operations: "Commands and queries",
+    },
+    /** The capabilities (docs/specs/plugins.md, "Capabilities"), each by a name and the sentence of what it opens, as an administrator reads them before consenting. */
+    capability: {
+      files: {
+        name: "Files",
+        opens: "Keeps files on its records, within the bytes the deployment allows.",
+      },
+      "people:read": { name: "People", opens: "Reads the people the person may see." },
+      "people:read:all": {
+        name: "Everyone",
+        opens: "Reads everyone in the workspace, from its jobs and hooks too.",
+      },
+      "projects:read": {
+        name: "Projects",
+        opens: "Reads the projects and members the person may see.",
+      },
+      "projects:read:all": {
+        name: "Every project",
+        opens: "Reads every project and its members.",
+      },
+      "board:read": {
+        name: "Board",
+        opens:
+          "Reads the tasks, decisions, runs, pages and events of its board projects, and of the project a call is on.",
+      },
+      "board:tasks": {
+        name: "Tasks",
+        opens: "Creates tasks in its projects; changes, closes and comments on its own.",
+      },
+      "board:decisions": {
+        name: "Decisions",
+        opens: "Raises decisions in its projects and reads the answers to its own.",
+      },
+      "board:documents": {
+        name: "Pages",
+        opens: "Writes pages in a folder of its own in its projects.",
+      },
+      "events:console": {
+        name: "Console events",
+        opens: "Runs hooks on what happens in its board projects.",
+      },
+      "events:plugins": {
+        name: "Other plugins' events",
+        opens: "Runs hooks on the events other plugins emit.",
+      },
+      jobs: { name: "Schedule", opens: "Runs at the times it names." },
+      endpoints: {
+        name: "Inbound requests",
+        opens: "Takes requests under its own path, a person's or a webhook's.",
+      },
+      "storage:sql": {
+        name: "Own database schema",
+        opens: "Gets a schema and a login role of its own in the console's database.",
+      },
+      outbound: (host: string) => ({
+        name: `Requests to ${host}`,
+        opens: `Sends https requests to ${host}.`,
+      }),
+      plugins: (key: string) => ({
+        name: `Plugin ${key}`,
+        opens: `Calls the API of the plugin ${key}, as the person.`,
+      }),
+    },
   },
 
   shell: {
@@ -407,6 +548,8 @@ export const en = {
     about: "about",
     answeredBy: "answered",
     context: "Context",
+    files: "Files",
+    picture: (name: string) => `The picture ${name}`,
     whatFollowed: "What followed",
     nothingWritten: "Nothing written yet.",
     outcomePlaceholder: "What was done with the answer, and what came of it, in Markdown.",
@@ -416,6 +559,11 @@ export const en = {
       question: "Question",
       context: "Context",
       contextPlaceholder: "What a person needs to know to answer, in Markdown.",
+      files: "Files",
+      chooseFiles: "Add files",
+      filesHint:
+        "A picture pasted or chosen here goes with the decision; ![words](its name) places it in the context.",
+      removeFile: (name: string) => `Take ${name} out`,
       about: "About",
       noTask: "No task in particular",
       decider: "Who decides",
@@ -595,6 +743,8 @@ export const en = {
     workspace: {
       title: "Workspace",
       aria: "Workspace settings",
+      consoleVersion: "Console version",
+      consoleTakes: (range: string) => `Takes the console command ${range}`,
       peopleVisibility: "Member visibility",
       peopleVisibilityHint:
         "Whom a member sees on the People page and in the pickers: everyone of the workspace, or only the people they share a project with. An administrator always sees everyone, and a project open to the workspace has everyone in it.",
@@ -640,6 +790,17 @@ export const en = {
     as: (agent: string) => `as ${agent}`,
     asTitle: "The agent the person acted through",
     aTask: "a task",
+    aPlugin: "a plugin",
+    /** After the sentence of a board's event a plugin caused (ADR-0052). */
+    throughPlugin: (plugin: string) => `through the plugin ${plugin}`,
+    everyone: "everyone",
+    membersOf: (project: string) => `the members of ${project}`,
+    outcome: {
+      ok: "done",
+      refused: "refused",
+      waiting: "waiting for a decision",
+      failed: "failed",
+    } as Readonly<Record<string, string>>,
     aProject: "a project",
     someone: "someone",
     something: "something",
@@ -725,6 +886,20 @@ export const en = {
       documentArchived: (page: string) => `archived ${page}`,
       documentRestored: (page: string) => `restored ${page}`,
       fileAttached: (label: string, page: string) => `attached ${label} to ${page}`,
+      pluginEnabled: (plugin: string) => `enabled the plugin ${plugin}`,
+      pluginDisabled: (plugin: string) => `disabled the plugin ${plugin}`,
+      pluginConfigured: (fields: string, plugin: string) =>
+        `changed ${fields} of the plugin ${plugin}`,
+      pluginGranted: (role: string, who: string, plugin: string) =>
+        `gave ${who} the role ${role} in the plugin ${plugin}`,
+      pluginRevoked: (role: string, who: string, plugin: string) =>
+        `took the role ${role} from ${who} in the plugin ${plugin}`,
+      pluginUpgraded: (plugin: string, version: string) =>
+        `brought the plugin ${plugin} to ${version}`,
+      pluginCommand: (command: string, plugin: string, outcome: string) =>
+        `ran ${command} of the plugin ${plugin}: ${outcome}`,
+      pluginPurged: (plugin: string) => `purged the plugin ${plugin}: everything it kept is gone`,
+      pluginFailed: (plugin: string, problem: string) => `the plugin ${plugin} failed: ${problem}`,
     },
   },
 

package/src/i18n/ko.ts

@@ -8,6 +8,14 @@ export const ko: Messages = {
   label: "한국어",
 
   vocabulary: {
+    pluginState: {
+      installed: "설치됨",
+      enabled: "활성",
+      needs_consent: "동의 필요",
+      disabled: "비활성",
+      failed: "실패",
+      orphaned: "패키지 없음",
+    },
     state: {
       idea: "아이디어",
       ready: "준비됨",
@@ -105,6 +113,122 @@ export const ko: Messages = {
     skills: "스킬",
     members: "멤버",
     settings: "설정",
+    plugins: "플러그인",
+    pluginGroups: {
+      people: "사람",
+      customers: "고객",
+      money: "돈",
+      operations: "운영",
+      marketing: "마케팅",
+      engineering: "엔지니어링",
+      reports: "보고",
+    },
+  },
+
+  plugins: {
+    frame: (name) => `${name}, 플러그인 페이지`,
+    noPage: {
+      title: "여기엔 없습니다",
+      body: "이 플러그인에는 볼 수 있는 페이지가 없거나, 이 프로젝트에 올라가 있지 않습니다.",
+    },
+    settings: {
+      title: "플러그인",
+      empty: { title: "플러그인 없음", body: "이 콘솔의 이미지에 설치된 플러그인이 없습니다." },
+      none: "콘솔에 플러그인 디렉터리가 없어 설치할 수 없습니다.",
+      about: "개요",
+      problems: "실행할 수 없는 이유",
+      nothing: "없음",
+      capabilities: "권한",
+      board: "보드 프로젝트",
+      boardHint: "플러그인의 결정, 태스크, 문서가 가는 곳입니다.",
+      boardNone: "없음",
+      boardCreate: "새 프로젝트",
+      boardChoose: "기존 프로젝트",
+      boardKey: "키",
+      boardName: "이름",
+      boardDescription: "설명",
+      projects: "프로젝트",
+      projectsAll: "모든 프로젝트",
+      projectsSome: "일부 프로젝트",
+      settingsForm: "설정",
+      secretSet: (when) => `${when} 설정됨`,
+      secretUnset: "설정 안 됨",
+      secretNew: "새 값",
+      enable: "활성화",
+      disable: "비활성화",
+      roles: "역할",
+      rolesNone: "역할이 없어 모든 멤버가 쓸 수 있습니다.",
+      roleDefault: "기본",
+      everyMember: "모든 멤버",
+      grantEveryone: "모두",
+      grantMembersOf: (project) => `${project}의 멤버`,
+      grantPeople: "사람",
+      grantProjects: "프로젝트의 멤버",
+      grantWhom: "부여할 대상…",
+      grant: "부여",
+      revoke: "회수",
+      events: "일어난 일",
+      noEvents: "아직 없습니다.",
+      data: "데이터",
+      export: "내보내기",
+      exportHint: "레코드와 그 버전을 JSON Lines로 받습니다.",
+      exportLink: "내려받기",
+      purge: "삭제",
+      purgeHint: "콘솔에 있는 레코드, 파일, 역할, 비밀을 지웁니다. 보드에 남긴 것은 남습니다.",
+      purgeDisabledFirst: "삭제하려면 먼저 비활성화하세요.",
+      purgeConfirm: (key) => `${key} 입력`,
+      purged: "삭제했습니다.",
+      agentNote: "에이전트에게",
+      operations: "명령과 조회",
+    },
+    capability: {
+      files: { name: "파일", opens: "레코드에 파일을 붙입니다. 배포가 허용한 용량까지." },
+      "people:read": { name: "사람 읽기", opens: "보는 사람이 볼 수 있는 사람들을 읽습니다." },
+      "people:read:all": {
+        name: "모든 사람 읽기",
+        opens: "워크스페이스의 모든 사람을 읽습니다. 예약 실행과 훅에서도.",
+      },
+      "projects:read": {
+        name: "프로젝트 읽기",
+        opens: "보는 사람이 볼 수 있는 프로젝트와 멤버를 읽습니다.",
+      },
+      "projects:read:all": {
+        name: "모든 프로젝트 읽기",
+        opens: "모든 프로젝트와 멤버를 읽습니다.",
+      },
+      "board:read": {
+        name: "보드 읽기",
+        opens: "보드 프로젝트와 호출된 프로젝트의 태스크, 결정, 실행, 문서, 이벤트를 읽습니다.",
+      },
+      "board:tasks": {
+        name: "태스크",
+        opens: "자기 프로젝트에 태스크를 만들고, 만든 것을 바꾸고 닫고 댓글을 답니다.",
+      },
+      "board:decisions": { name: "결정", opens: "자기 프로젝트에 결정을 올리고 그 답을 읽습니다." },
+      "board:documents": { name: "문서", opens: "자기 프로젝트의 문서에 자기 폴더를 두고 씁니다." },
+      "events:console": {
+        name: "콘솔 이벤트",
+        opens: "보드 프로젝트에서 일어나는 일에 훅을 겁니다.",
+      },
+      "events:plugins": {
+        name: "다른 플러그인의 이벤트",
+        opens: "다른 플러그인이 내는 이벤트에 훅을 겁니다.",
+      },
+      jobs: { name: "예약 실행", opens: "정해진 시간에 실행됩니다." },
+      endpoints: {
+        name: "요청 받기",
+        opens: "자기 경로로 오는 요청을 받습니다. 사람의 요청이나 웹훅.",
+      },
+      "storage:sql": {
+        name: "전용 데이터베이스 스키마",
+        opens: "콘솔 데이터베이스에 전용 스키마와 로그인 역할을 갖습니다.",
+      },
+      outbound: (host) => ({ name: `${host}로 요청`, opens: `${host}에 https 요청을 보냅니다.` }),
+      plugins: (key) => ({
+        name: `플러그인 ${key} 호출`,
+        opens: `플러그인 ${key}의 API를 호출한 사람의 권한으로 호출합니다.`,
+      }),
+    },
   },
 
   shell: {
@@ -365,6 +489,8 @@ export const ko: Messages = {
     about: "관련 작업:",
     answeredBy: "답변",
     context: "맥락",
+    files: "파일",
+    picture: (name) => `그림 ${name}`,
     whatFollowed: "그 뒤에 일어난 일",
     nothingWritten: "아직 적힌 것이 없습니다.",
     outcomePlaceholder: "답변으로 무엇을 했고 무엇이 됐는지, Markdown으로.",
@@ -374,6 +500,11 @@ export const ko: Messages = {
       question: "질문",
       context: "맥락",
       contextPlaceholder: "답하려면 알아야 할 것, Markdown으로.",
+      files: "파일",
+      chooseFiles: "파일 추가",
+      filesHint:
+        "여기에 붙여 넣거나 고른 그림은 결정과 함께 올라갑니다. ![설명](파일 이름)으로 맥락에 넣을 수 있습니다.",
+      removeFile: (name) => `${name} 빼기`,
       about: "관련 작업",
       noTask: "특정 작업 없음",
       decider: "결정할 사람",
@@ -551,6 +682,8 @@ export const ko: Messages = {
     workspace: {
       title: "워크스페이스",
       aria: "워크스페이스 설정",
+      consoleVersion: "콘솔 버전",
+      consoleTakes: (range) => `받는 console 명령: ${range}`,
       peopleVisibility: "멤버 공개 범위",
       peopleVisibilityHint:
         "멤버가 사람들 페이지와 선택 목록에서 보는 범위: 워크스페이스의 모두, 또는 같은 프로젝트에 속한 사람만. 관리자는 언제나 모두를 보고, 워크스페이스에 공개된 프로젝트에는 모두가 속합니다.",
@@ -596,6 +729,16 @@ export const ko: Messages = {
     as: (agent) => `${agent}(으)로`,
     asTitle: "그 사람이 사용한 에이전트",
     aTask: "작업",
+    aPlugin: "플러그인",
+    throughPlugin: (plugin) => `플러그인 ${plugin}을(를) 통해`,
+    everyone: "모든 구성원",
+    membersOf: (project) => `${project}의 구성원`,
+    outcome: {
+      ok: "완료",
+      refused: "거절됨",
+      waiting: "결정 대기",
+      failed: "실패",
+    },
     aProject: "프로젝트",
     someone: "누군가",
     something: "무언가",
@@ -678,6 +821,18 @@ export const ko: Messages = {
       documentArchived: (page) => `${page}을(를) 보관했습니다`,
       documentRestored: (page) => `${page}을(를) 복원했습니다`,
       fileAttached: (label, page) => `${page}에 ${label}을(를) 첨부했습니다`,
+      pluginEnabled: (plugin) => `플러그인 ${plugin}을(를) 활성화했습니다`,
+      pluginDisabled: (plugin) => `플러그인 ${plugin}을(를) 비활성화했습니다`,
+      pluginConfigured: (fields, plugin) => `플러그인 ${plugin}의 ${fields}을(를) 바꿨습니다`,
+      pluginGranted: (role, who, plugin) =>
+        `${who}에게 플러그인 ${plugin}의 ${role} 역할을 주었습니다`,
+      pluginRevoked: (role, who, plugin) =>
+        `${who}에게서 플러그인 ${plugin}의 ${role} 역할을 거두었습니다`,
+      pluginUpgraded: (plugin, version) => `플러그인 ${plugin}을(를) ${version}으로 올렸습니다`,
+      pluginCommand: (command, plugin, outcome) =>
+        `플러그인 ${plugin}의 ${command}을(를) 실행했습니다: ${outcome}`,
+      pluginPurged: (plugin) => `플러그인 ${plugin}을(를) 완전히 지웠습니다`,
+      pluginFailed: (plugin, problem) => `플러그인 ${plugin}이(가) 실패했습니다: ${problem}`,
     },
   },
 

package/src/index.ts

@@ -131,6 +131,15 @@ export {
   ZOOM_STEP,
   zoomAround,
 } from "./components/pictures.js";
+export {
+  BridgeRefusal,
+  PluginFrame,
+  type PluginFrameProps,
+  PluginWidgets,
+  type PluginWidgetsProps,
+  performBridgeCall,
+  readTheme,
+} from "./components/plugin-frame.js";
 export {
   keyOf,
   MemberList,
@@ -303,6 +312,8 @@ export {
   type ProjectPage,
   personAgentsHref,
   personWorkHref,
+  pluginHref,
+  pluginSettingsHref,
   projectHref,
   projectSettingsHref,
   type Route,
@@ -314,4 +325,5 @@ export {
   withoutSignInParam,
   workHref,
 } from "./router.js";
+export { CONSOLE_TOKENS } from "./tokens.js";
 export { errorWords, useAction } from "./use-action.js";

package/src/limits.ts

@@ -33,6 +33,8 @@ export const MAX_ARTIFACTS_PER_RUN = 50;
 /** How many comments one task carries, and how many files one comment carries, together within `MAX_FILE_BYTES`. */
 export const MAX_COMMENTS_PER_TASK = 500;
 export const MAX_FILES_PER_COMMENT = 10;
+/** How many files one decision carries, put on it when it is raised (ADR-0055), together within `MAX_FILE_BYTES`. */
+export const MAX_FILES_PER_DECISION = 10;
 /** A file a run hands in: how many bytes, and its name, one line without a path. */
 export const MAX_FILE_BYTES = 10 * 1024 * 1024;
 export const MAX_FILE_NAME_LENGTH = 200;