teamcopilot 0.0.1

package/dist/utils/skill-approval-snapshot.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectCurrentSkillSnapshot = collectCurrentSkillSnapshot;
+exports.loadApprovedSkillSnapshotFromDb = loadApprovedSkillSnapshotFromDb;
+exports.approveSkillWithSnapshot = approveSkillWithSnapshot;
+exports.buildSkillApprovalDiffResponse = buildSkillApprovalDiffResponse;
+exports.getSkillSnapshotApprovalState = getSkillSnapshotApprovalState;
+exports.restoreSkillToApprovedSnapshot = restoreSkillToApprovedSnapshot;
+const skill_1 = require("./skill");
+const approval_snapshot_common_1 = require("./approval-snapshot-common");
+function getSkillSnapshotConfig(slug) {
+    return {
+        resource_kind: "skill",
+        slug,
+        resource_label: "skill",
+        root_path: (0, skill_1.getSkillPath)(slug),
+        ensure_resource_exists: async () => {
+            await (0, skill_1.readSkillManifestAndEnsurePermissions)(slug);
+        }
+    };
+}
+function collectCurrentSkillSnapshot(slug) {
+    return (0, approval_snapshot_common_1.collectCurrentResourceSnapshot)(getSkillSnapshotConfig(slug));
+}
+async function loadApprovedSkillSnapshotFromDb(slug) {
+    return (0, approval_snapshot_common_1.loadApprovedSnapshotFromDb)("skill", slug);
+}
+async function approveSkillWithSnapshot(slug, userId) {
+    return (0, approval_snapshot_common_1.approveResourceWithSnapshot)(getSkillSnapshotConfig(slug), userId);
+}
+function buildSkillApprovalDiffResponse(previous, current) {
+    return (0, approval_snapshot_common_1.buildApprovalDiffResponse)(previous, current);
+}
+async function getSkillSnapshotApprovalState(slug) {
+    return (0, approval_snapshot_common_1.getResourceSnapshotApprovalState)(getSkillSnapshotConfig(slug));
+}
+async function restoreSkillToApprovedSnapshot(slug, userId) {
+    return (0, approval_snapshot_common_1.restoreResourceToApprovedSnapshot)(getSkillSnapshotConfig(slug), userId);
+}

package/dist/utils/skill-files.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSkillPath = exports.renameSkillPath = exports.uploadSkillFileFromTempPath = exports.createSkillFileOrFolder = exports.saveSkillFileContent = exports.readSkillFileContent = exports.listSkillDirectory = void 0;
+const resource_files_1 = require("./resource-files");
+const skill_1 = require("./skill");
+const skillFileManager = (0, resource_files_1.createResourceFileManager)({
+    getResourcePath: skill_1.getSkillPath,
+    resourceLabel: "skill",
+    editorLabel: "Skill",
+});
+exports.listSkillDirectory = skillFileManager.listDirectory;
+exports.readSkillFileContent = skillFileManager.readFileContent;
+exports.saveSkillFileContent = skillFileManager.saveFileContent;
+exports.createSkillFileOrFolder = skillFileManager.createFileOrFolder;
+exports.uploadSkillFileFromTempPath = skillFileManager.uploadFileFromTempPath;
+exports.renameSkillPath = skillFileManager.renamePath;
+exports.deleteSkillPath = skillFileManager.deletePath;

package/dist/utils/skill-permissions.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSkillAccessPermissionWithUsers = getSkillAccessPermissionWithUsers;
+exports.setSkillAccessPermissions = setSkillAccessPermissions;
+exports.addApproverToSkillAccessPermissionsIfRestricted = addApproverToSkillAccessPermissionsIfRestricted;
+const permission_common_1 = require("./permission-common");
+async function getSkillAccessPermissionWithUsers(slug) {
+    return (0, permission_common_1.getResourcePermissionWithUsers)("skill", slug, "Skill access");
+}
+async function setSkillAccessPermissions(slug, payload, ownerUserId) {
+    return (0, permission_common_1.setResourcePermissions)("skill", slug, payload, ownerUserId);
+}
+async function addApproverToSkillAccessPermissionsIfRestricted(slug, approverUserId, ownerUserId) {
+    await (0, permission_common_1.addUserToResourcePermissionsIfRestricted)("skill", slug, approverUserId, ownerUserId);
+}

package/dist/utils/skill.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSkillPath = getSkillPath;
+exports.deleteSkill = deleteSkill;
+exports.listSkillSlugs = listSkillSlugs;
+exports.createSkill = createSkill;
+exports.getOrCreateSkillMetadataAndEnsurePermission = getOrCreateSkillMetadataAndEnsurePermission;
+exports.readSkillManifestAndEnsurePermissions = readSkillManifestAndEnsurePermissions;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const client_1 = __importDefault(require("../prisma/client"));
+const workspace_sync_1 = require("./workspace-sync");
+const permission_common_1 = require("./permission-common");
+function getSkillsRootPath() {
+    return path_1.default.join((0, workspace_sync_1.getWorkspaceDirFromEnv)(), "custom-skills");
+}
+function getSkillPath(slug) {
+    return path_1.default.join(getSkillsRootPath(), slug);
+}
+function deleteSkillDirectory(slug) {
+    const skillPath = getSkillPath(slug);
+    if (!fs_1.default.existsSync(skillPath)) {
+        throw {
+            status: 404,
+            message: `Skill not found for slug: ${slug}`
+        };
+    }
+    fs_1.default.rmSync(skillPath, { recursive: true, force: false });
+}
+async function deleteSkill(slug) {
+    await client_1.default.resource_metadata.deleteMany({
+        where: {
+            resource_kind: "skill",
+            resource_slug: slug
+        }
+    });
+    await client_1.default.resource_permissions.deleteMany({
+        where: {
+            resource_kind: "skill",
+            resource_slug: slug
+        }
+    });
+    if (fs_1.default.existsSync(getSkillPath(slug))) {
+        deleteSkillDirectory(slug);
+    }
+}
+function getSkillManifestPath(slug) {
+    return path_1.default.join(getSkillPath(slug), "SKILL.md");
+}
+function assertSkillSlug(slug) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug)) {
+        throw {
+            status: 400,
+            message: "Invalid skill slug. Expected lowercase letters/numbers with optional hyphens."
+        };
+    }
+}
+function listSkillSlugs() {
+    const skillsDir = getSkillsRootPath();
+    if (!fs_1.default.existsSync(skillsDir)) {
+        return [];
+    }
+    const entries = fs_1.default.readdirSync(skillsDir, { withFileTypes: true });
+    const slugs = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const canonicalManifestPath = path_1.default.join(skillsDir, entry.name, "SKILL.md");
+        if (fs_1.default.existsSync(canonicalManifestPath)) {
+            slugs.push(entry.name);
+        }
+    }
+    return slugs;
+}
+function extractFrontmatterValue(frontmatter, key) {
+    const pattern = new RegExp(`^${key}\\s*:\\s*(.+)$`, "m");
+    const match = frontmatter.match(pattern);
+    if (!match) {
+        return null;
+    }
+    return match[1]?.trim().replace(/^["']|["']$/g, "") ?? null;
+}
+function readSkillManifest(slug) {
+    const skillManifestPath = getSkillManifestPath(slug);
+    if (!fs_1.default.existsSync(skillManifestPath)) {
+        throw {
+            status: 404,
+            message: `Skill manifest not found for slug: ${slug}`
+        };
+    }
+    const content = fs_1.default.readFileSync(skillManifestPath, "utf-8");
+    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*/);
+    const frontmatter = frontmatterMatch?.[1] ?? "";
+    const name = extractFrontmatterValue(frontmatter, "name") ?? slug;
+    const description = extractFrontmatterValue(frontmatter, "description") ?? "";
+    return {
+        name,
+        description,
+    };
+}
+function toSkillFrontmatterValue(value) {
+    return JSON.stringify(value.trim());
+}
+async function createSkill(input) {
+    const slug = input.slug.trim();
+    const name = input.slug.trim();
+    assertSkillSlug(slug);
+    if (!name) {
+        throw {
+            status: 400,
+            message: "Skill name is required"
+        };
+    }
+    if (name !== slug) {
+        throw {
+            status: 400,
+            message: "Skill name and slug must be the same value"
+        };
+    }
+    const existingMetadata = await client_1.default.resource_metadata.findUnique({
+        where: {
+            resource_kind_resource_slug: {
+                resource_kind: "skill",
+                resource_slug: slug
+            }
+        },
+        select: { resource_slug: true }
+    });
+    if (existingMetadata) {
+        throw {
+            status: 409,
+            message: `Skill with slug "${slug}" already exists`
+        };
+    }
+    const skillPath = getSkillPath(slug);
+    if (fs_1.default.existsSync(skillPath)) {
+        throw {
+            status: 409,
+            message: `Skill with slug "${slug}" already exists`
+        };
+    }
+    fs_1.default.mkdirSync(skillPath, { recursive: false });
+    const skillMdPath = getSkillManifestPath(slug);
+    const body = `---\nname: ${toSkillFrontmatterValue(name)}\ndescription: ${toSkillFrontmatterValue("")}\n---\n\n# ${name}\n\nDescribe what this skill does.\n\n## Instructions\n\nAdd detailed, actionable instructions for the agent here.\n`;
+    fs_1.default.writeFileSync(skillMdPath, body, "utf-8");
+    const now = BigInt(Date.now());
+    await client_1.default.$transaction(async (tx) => {
+        await tx.resource_metadata.create({
+            data: {
+                resource_kind: "skill",
+                resource_slug: slug,
+                created_by_user_id: input.createdByUserId,
+                approved_by_user_id: null,
+                created_at: now,
+                updated_at: now,
+            }
+        });
+        await tx.resource_permissions.create({
+            data: {
+                resource_kind: "skill",
+                resource_slug: slug,
+                permission_mode: "restricted",
+                created_at: now,
+                updated_at: now,
+                allowedUsers: {
+                    create: {
+                        user_id: input.createdByUserId,
+                        created_at: now
+                    }
+                }
+            }
+        });
+    });
+}
+async function getOrCreateSkillMetadataAndEnsurePermission(slug) {
+    readSkillManifest(slug);
+    const existing = await client_1.default.resource_metadata.findUnique({
+        where: {
+            resource_kind_resource_slug: {
+                resource_kind: "skill",
+                resource_slug: slug
+            }
+        }
+    });
+    if (existing) {
+        const metadata = {
+            skill_slug: existing.resource_slug,
+            created_by_user_id: existing.created_by_user_id,
+            approved_by_user_id: existing.approved_by_user_id,
+        };
+        await (0, permission_common_1.ensureResourcePermissions)("skill", slug, [metadata.created_by_user_id, metadata.approved_by_user_id].filter((id) => Boolean(id)));
+        return metadata;
+    }
+    const now = BigInt(Date.now());
+    const created = await client_1.default.resource_metadata.create({
+        data: {
+            resource_kind: "skill",
+            resource_slug: slug,
+            created_at: now,
+            updated_at: now,
+        }
+    });
+    await (0, permission_common_1.ensureResourcePermissions)("skill", slug, []);
+    return {
+        skill_slug: created.resource_slug,
+        created_by_user_id: created.created_by_user_id,
+        approved_by_user_id: created.approved_by_user_id,
+    };
+}
+async function readSkillManifestAndEnsurePermissions(slug) {
+    const manifest = readSkillManifest(slug);
+    const metadata = await getOrCreateSkillMetadataAndEnsurePermission(slug);
+    return { manifest, metadata };
+}

package/dist/utils/user-role.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEngineerUser = isEngineerUser;
+const client_1 = __importDefault(require("../prisma/client"));
+async function isEngineerUser(userId) {
+    const user = await client_1.default.users.findUnique({
+        where: { id: userId },
+        select: { role: true }
+    });
+    return user?.role === "Engineer";
+}

package/dist/utils/workflow-approval-snapshot.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildApprovalDiffResponse = void 0;
+exports.collectCurrentWorkflowSnapshot = collectCurrentWorkflowSnapshot;
+exports.loadApprovedSnapshotFromDb = loadApprovedSnapshotFromDb;
+exports.approveWorkflowWithSnapshot = approveWorkflowWithSnapshot;
+exports.getWorkflowSnapshotApprovalState = getWorkflowSnapshotApprovalState;
+exports.restoreWorkflowToApprovedSnapshot = restoreWorkflowToApprovedSnapshot;
+const workflow_1 = require("./workflow");
+const workflow_2 = require("./workflow");
+const approval_snapshot_common_1 = require("./approval-snapshot-common");
+Object.defineProperty(exports, "buildApprovalDiffResponse", { enumerable: true, get: function () { return approval_snapshot_common_1.buildApprovalDiffResponse; } });
+function getWorkflowSnapshotConfig(slug) {
+    return {
+        resource_kind: "workflow",
+        slug,
+        resource_label: "workflow",
+        root_path: (0, workflow_2.getWorkflowPath)(slug),
+        ensure_resource_exists: async () => {
+            await (0, workflow_1.readWorkflowManifestAndEnsurePermissions)(slug);
+        }
+    };
+}
+function collectCurrentWorkflowSnapshot(slug) {
+    return (0, approval_snapshot_common_1.collectCurrentResourceSnapshot)(getWorkflowSnapshotConfig(slug));
+}
+async function loadApprovedSnapshotFromDb(slug) {
+    return (0, approval_snapshot_common_1.loadApprovedSnapshotFromDb)("workflow", slug);
+}
+async function approveWorkflowWithSnapshot(slug, userId) {
+    return (0, approval_snapshot_common_1.approveResourceWithSnapshot)(getWorkflowSnapshotConfig(slug), userId);
+}
+async function getWorkflowSnapshotApprovalState(slug) {
+    return (0, approval_snapshot_common_1.getResourceSnapshotApprovalState)(getWorkflowSnapshotConfig(slug));
+}
+async function restoreWorkflowToApprovedSnapshot(slug, userId) {
+    return (0, approval_snapshot_common_1.restoreResourceToApprovedSnapshot)(getWorkflowSnapshotConfig(slug), userId);
+}

package/dist/utils/workflow-files.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteWorkflowPath = exports.renameWorkflowPath = exports.uploadWorkflowFileFromTempPath = exports.createWorkflowFileOrFolder = exports.saveWorkflowFileContent = exports.readWorkflowFileContent = exports.listWorkflowDirectory = void 0;
+const resource_files_1 = require("./resource-files");
+const workflow_1 = require("./workflow");
+const workflowFileManager = (0, resource_files_1.createResourceFileManager)({
+    getResourcePath: workflow_1.getWorkflowPath,
+    resourceLabel: "workflow",
+    editorLabel: "Workflow",
+});
+exports.listWorkflowDirectory = workflowFileManager.listDirectory;
+exports.readWorkflowFileContent = workflowFileManager.readFileContent;
+exports.saveWorkflowFileContent = workflowFileManager.saveFileContent;
+exports.createWorkflowFileOrFolder = workflowFileManager.createFileOrFolder;
+exports.uploadWorkflowFileFromTempPath = workflowFileManager.uploadFileFromTempPath;
+exports.renameWorkflowPath = workflowFileManager.renamePath;
+exports.deleteWorkflowPath = workflowFileManager.deletePath;

package/dist/utils/workflow-interruption.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkflowSessionInterrupted = isWorkflowSessionInterrupted;
+exports.markWorkflowSessionAborted = markWorkflowSessionAborted;
+const client_1 = __importDefault(require("../prisma/client"));
+const opencode_client_1 = require("./opencode-client");
+async function isWorkflowSessionInterrupted(sessionId, workspaceDir) {
+    const isManualSession = sessionId.startsWith("manual-");
+    if (isManualSession) {
+        const aborted = await client_1.default.workflow_aborted_sessions.findUnique({
+            where: { session_id: sessionId }
+        });
+        return Boolean(aborted);
+    }
+    const port = (0, opencode_client_1.getOpencodePort)();
+    const response = await fetch(`http://localhost:${port}/session/status?directory=${encodeURIComponent(workspaceDir)}`);
+    if (response.ok) {
+        const statuses = await response.json();
+        const state = statuses[sessionId] ?? null;
+        const sessionType = typeof state?.type === "string" ? state.type : null;
+        // Opencode may remove a session from this status map right after abort/interrupt.
+        // If it is not explicitly "busy", treat it as interrupted.
+        return sessionType !== "busy";
+    }
+    return false;
+}
+async function markWorkflowSessionAborted(sessionId) {
+    const now = Date.now();
+    const cutoff = now - (24 * 60 * 60 * 1000);
+    await client_1.default.workflow_aborted_sessions.deleteMany({
+        where: {
+            created_at: {
+                lt: BigInt(cutoff)
+            }
+        }
+    });
+    await client_1.default.workflow_aborted_sessions.upsert({
+        where: { session_id: sessionId },
+        create: {
+            session_id: sessionId,
+            created_at: BigInt(now)
+        },
+        update: {
+            created_at: BigInt(now)
+        }
+    });
+}

package/dist/utils/workflow-permissions.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureWorkflowRunPermissionsForMetadata = ensureWorkflowRunPermissionsForMetadata;
+exports.initializeWorkflowRunPermissionsForCreator = initializeWorkflowRunPermissionsForCreator;
+exports.addApproverToWorkflowRunPermissionsIfRestricted = addApproverToWorkflowRunPermissionsIfRestricted;
+exports.getWorkflowRunPermissionWithUsers = getWorkflowRunPermissionWithUsers;
+exports.setWorkflowRunPermissions = setWorkflowRunPermissions;
+const permission_common_1 = require("./permission-common");
+function getDefaultCandidateUserIds(metadata) {
+    const ids = [metadata.created_by_user_id, metadata.approved_by_user_id].filter((id) => Boolean(id));
+    return Array.from(new Set(ids));
+}
+async function ensureWorkflowRunPermissionsForMetadata(slug, metadata) {
+    await (0, permission_common_1.ensureResourcePermissions)("workflow", slug, getDefaultCandidateUserIds(metadata));
+}
+async function initializeWorkflowRunPermissionsForCreator(slug, creatorUserId) {
+    await (0, permission_common_1.initializeResourcePermissionsForCreator)("workflow", slug, creatorUserId);
+}
+async function addApproverToWorkflowRunPermissionsIfRestricted(slug, approverUserId, ownerUserId) {
+    await (0, permission_common_1.addUserToResourcePermissionsIfRestricted)("workflow", slug, approverUserId, ownerUserId);
+}
+async function getWorkflowRunPermissionWithUsers(slug) {
+    return (0, permission_common_1.getResourcePermissionWithUsers)("workflow", slug, "Workflow run");
+}
+async function setWorkflowRunPermissions(slug, payload, ownerUserId) {
+    return (0, permission_common_1.setResourcePermissions)("workflow", slug, payload, ownerUserId);
+}