openwork-server 0.1.0

package/dist/skills.js

@@ -0,0 +1,143 @@
+import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { parseFrontmatter, buildFrontmatter } from "./frontmatter.js";
+import { exists } from "./utils.js";
+import { validateDescription, validateSkillName } from "./validators.js";
+import { ApiError } from "./errors.js";
+import { projectSkillsDir } from "./workspace-files.js";
+async function findWorkspaceRoots(workspaceRoot) {
+    const roots = [];
+    let current = resolve(workspaceRoot);
+    while (true) {
+        roots.push(current);
+        const gitPath = join(current, ".git");
+        if (await exists(gitPath))
+            break;
+        const parent = resolve(current, "..");
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return roots;
+}
+const extractTriggerFromBody = (body) => {
+    const lines = body.split(/\r?\n/);
+    let inWhenSection = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (/^#{1,6}\s+/.test(trimmed)) {
+            const heading = trimmed.replace(/^#{1,6}\s+/, "").trim();
+            inWhenSection = /^when to use$/i.test(heading);
+            continue;
+        }
+        if (!inWhenSection)
+            continue;
+        const cleaned = trimmed
+            .replace(/^[-*+]\s+/, "")
+            .replace(/^\d+[.)]\s+/, "")
+            .trim();
+        if (cleaned)
+            return cleaned;
+    }
+    return "";
+};
+async function listSkillsInDir(dir, scope) {
+    if (!(await exists(dir)))
+        return [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    const items = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillPath = join(dir, entry.name, "SKILL.md");
+        if (!(await exists(skillPath)))
+            continue;
+        const content = await readFile(skillPath, "utf8");
+        const { data, body } = parseFrontmatter(content);
+        const name = typeof data.name === "string" ? data.name : entry.name;
+        const description = typeof data.description === "string" ? data.description : "";
+        const trigger = typeof data.trigger === "string"
+            ? data.trigger
+            : typeof data.when === "string"
+                ? data.when
+                : extractTriggerFromBody(body);
+        try {
+            validateSkillName(name);
+            validateDescription(description);
+        }
+        catch {
+            continue;
+        }
+        if (name !== entry.name)
+            continue;
+        items.push({
+            name,
+            description,
+            path: skillPath,
+            scope,
+            trigger: trigger.trim() || undefined,
+        });
+    }
+    return items;
+}
+export async function listSkills(workspaceRoot, includeGlobal) {
+    const roots = await findWorkspaceRoots(workspaceRoot);
+    const items = [];
+    for (const root of roots) {
+        const opencodeDir = join(root, ".opencode", "skills");
+        const claudeDir = join(root, ".claude", "skills");
+        items.push(...(await listSkillsInDir(opencodeDir, "project")));
+        items.push(...(await listSkillsInDir(claudeDir, "project")));
+    }
+    if (includeGlobal) {
+        const globalOpenWork = join(homedir(), ".config", "opencode", "skills");
+        const globalClaude = join(homedir(), ".claude", "skills");
+        items.push(...(await listSkillsInDir(globalOpenWork, "global")));
+        items.push(...(await listSkillsInDir(globalClaude, "global")));
+    }
+    const seen = new Set();
+    return items.filter((item) => {
+        if (seen.has(item.name))
+            return false;
+        seen.add(item.name);
+        return true;
+    });
+}
+export async function upsertSkill(workspaceRoot, payload) {
+    const name = payload.name.trim();
+    validateSkillName(name);
+    if (!payload.content) {
+        throw new ApiError(400, "invalid_skill_content", "Skill content is required");
+    }
+    let content = payload.content;
+    const { data, body } = parseFrontmatter(payload.content);
+    if (Object.keys(data).length > 0) {
+        const frontmatterName = typeof data.name === "string" ? data.name : "";
+        const frontmatterDescription = typeof data.description === "string" ? data.description : "";
+        if (frontmatterName && frontmatterName !== name) {
+            throw new ApiError(400, "invalid_skill_name", "Skill frontmatter name must match payload name");
+        }
+        validateDescription(frontmatterDescription || payload.description);
+        const nextDescription = frontmatterDescription || payload.description || "";
+        const frontmatter = buildFrontmatter({
+            ...data,
+            name,
+            description: nextDescription,
+        });
+        content = frontmatter + body.replace(/^\n/, "");
+    }
+    else {
+        validateDescription(payload.description);
+        const frontmatter = buildFrontmatter({ name, description: payload.description });
+        content = frontmatter + payload.content.replace(/^\n/, "");
+    }
+    const baseDir = projectSkillsDir(workspaceRoot);
+    const skillDir = join(baseDir, name);
+    await mkdir(skillDir, { recursive: true });
+    const skillPath = join(skillDir, "SKILL.md");
+    await writeFile(skillPath, content.endsWith("\n") ? content : content + "\n", "utf8");
+    return skillPath;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.js

@@ -0,0 +1,51 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, stat } from "node:fs/promises";
+export async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureDir(path) {
+    await mkdir(path, { recursive: true });
+}
+export async function readJsonFile(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function hashToken(token) {
+    return createHash("sha256").update(token).digest("hex");
+}
+export function shortId() {
+    return randomUUID();
+}
+export function parseList(input) {
+    if (!input)
+        return [];
+    const trimmed = input.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith("[")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed.map((item) => String(item)).filter(Boolean);
+            }
+        }
+        catch {
+            return [];
+        }
+    }
+    return trimmed
+        .split(/[,;]/)
+        .map((value) => value.trim())
+        .filter(Boolean);
+}

package/dist/validators.js

@@ -0,0 +1,51 @@
+import { ApiError } from "./errors.js";
+const SKILL_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const COMMAND_NAME_REGEX = /^[A-Za-z0-9_-]+$/;
+const MCP_NAME_REGEX = /^[A-Za-z0-9_-]+$/;
+export function validateSkillName(name) {
+    if (!name || name.length < 1 || name.length > 64 || !SKILL_NAME_REGEX.test(name)) {
+        throw new ApiError(400, "invalid_skill_name", "Skill name must be kebab-case (1-64 chars)");
+    }
+}
+export function validateDescription(description) {
+    if (!description || description.length < 1 || description.length > 1024) {
+        throw new ApiError(422, "invalid_description", "Description must be 1-1024 characters");
+    }
+}
+export function validatePluginSpec(spec) {
+    if (!spec || spec.trim().length === 0) {
+        throw new ApiError(400, "invalid_plugin_spec", "Plugin spec is required");
+    }
+}
+export function sanitizeCommandName(name) {
+    const trimmed = name.trim().replace(/^\/+/, "");
+    return trimmed;
+}
+export function validateCommandName(name) {
+    if (!name || !COMMAND_NAME_REGEX.test(name)) {
+        throw new ApiError(400, "invalid_command_name", "Command name must be alphanumeric with _ or -");
+    }
+}
+export function validateMcpName(name) {
+    if (!name || name.startsWith("-") || !MCP_NAME_REGEX.test(name)) {
+        throw new ApiError(400, "invalid_mcp_name", "MCP name must be alphanumeric and not start with -");
+    }
+}
+export function validateMcpConfig(config) {
+    const type = config.type;
+    if (type !== "local" && type !== "remote") {
+        throw new ApiError(400, "invalid_mcp_config", "MCP config type must be local or remote");
+    }
+    if (type === "local") {
+        const command = config.command;
+        if (!Array.isArray(command) || command.length === 0) {
+            throw new ApiError(400, "invalid_mcp_config", "Local MCP requires command array");
+        }
+    }
+    if (type === "remote") {
+        const url = config.url;
+        if (!url || typeof url !== "string") {
+            throw new ApiError(400, "invalid_mcp_config", "Remote MCP requires url");
+        }
+    }
+}

package/dist/workspace-files.js

@@ -0,0 +1,23 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+export function opencodeConfigPath(workspaceRoot) {
+    const jsoncPath = join(workspaceRoot, "opencode.jsonc");
+    const jsonPath = join(workspaceRoot, "opencode.json");
+    if (existsSync(jsoncPath))
+        return jsoncPath;
+    if (existsSync(jsonPath))
+        return jsonPath;
+    return jsoncPath;
+}
+export function openworkConfigPath(workspaceRoot) {
+    return join(workspaceRoot, ".opencode", "openwork.json");
+}
+export function projectSkillsDir(workspaceRoot) {
+    return join(workspaceRoot, ".opencode", "skills");
+}
+export function projectCommandsDir(workspaceRoot) {
+    return join(workspaceRoot, ".opencode", "commands");
+}
+export function projectPluginsDir(workspaceRoot) {
+    return join(workspaceRoot, ".opencode", "plugins");
+}

package/dist/workspaces.js

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+import { basename, resolve } from "node:path";
+export function workspaceIdForPath(path) {
+    const hash = createHash("sha256").update(path).digest("hex");
+    return `ws_${hash.slice(0, 12)}`;
+}
+export function buildWorkspaceInfos(workspaces, cwd) {
+    return workspaces.map((workspace) => {
+        const resolvedPath = resolve(cwd, workspace.path);
+        return {
+            id: workspaceIdForPath(resolvedPath),
+            name: workspace.name ?? basename(resolvedPath),
+            path: resolvedPath,
+            workspaceType: workspace.workspaceType ?? "local",
+            baseUrl: workspace.baseUrl,
+            directory: workspace.directory,
+            opencodeUsername: workspace.opencodeUsername,
+            opencodePassword: workspace.opencodePassword,
+        };
+    });
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "openwork-server",
+  "version": "0.1.0",
+  "description": "Filesystem-backed API for OpenWork remote clients",
+  "type": "module",
+  "bin": {
+    "openwork-server": "dist/cli.js"
+  },
+  "scripts": {
+    "dev": "bun src/cli.ts",
+    "build": "tsc -p tsconfig.json",
+    "build:bin": "bun ./script/build.ts --outdir dist/bin",
+    "build:bin:all": "bun ./script/build.ts --outdir dist/bin --target bun-darwin-arm64 --target bun-darwin-x64 --target bun-linux-x64 --target bun-windows-x64",
+    "start": "bun dist/cli.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/different-ai/openwork.git",
+    "directory": "packages/server"
+  },
+  "homepage": "https://github.com/different-ai/openwork/tree/dev/packages/server",
+  "bugs": {
+    "url": "https://github.com/different-ai/openwork/issues"
+  },
+  "keywords": [
+    "openwork",
+    "server",
+    "opencode",
+    "headless",
+    "cli"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.2.1",
+    "minimatch": "^10.0.1",
+    "yaml": "^2.6.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/minimatch": "^5.1.2",
+    "bun-types": "^1.3.6",
+    "typescript": "^5.6.3"
+  },
+  "packageManager": "pnpm@10.27.0"
+}