@moretea-labs/forge 1.5.1 → 1.7.0

package/src/runtime/plugins/github-adapter.ts

@@ -7,6 +7,11 @@ import {
   refreshIssueWithGitHubPlugin,
   saveGitHubPluginConfig,
 } from '../../cli/github/plugin';
+import {
+  dispatchGitHubWorkflow,
+  listGitHubWorkflowRuns,
+  listGitHubWorkflows,
+} from '../../cli/github/github';
 import type {
   AssistantPluginActionDescriptor,
   AssistantPluginActionExecutionInput,
@@ -37,6 +42,20 @@ function githubPermissions(ready: boolean, projectConfigured: boolean): Assistan
       granted: ready && projectConfigured,
       required: projectConfigured,
     },
+    {
+      scope: 'github:actions:read',
+      mode: 'read',
+      description: 'List GitHub Actions workflows and recent workflow runs.',
+      granted: ready,
+      required: false,
+    },
+    {
+      scope: 'github:actions:write',
+      mode: 'write',
+      description: 'Dispatch an explicitly named workflow_dispatch workflow.',
+      granted: ready,
+      required: false,
+    },
     {
       scope: 'controller:issues:write',
       mode: 'write',
@@ -63,6 +82,13 @@ function githubCapabilities(): AssistantPluginCapability[] {
       scopes: ['github:projects:write'],
       actions: ['configure', 'publish_issue'],
     },
+    {
+      capabilityId: 'actions-ci',
+      title: 'GitHub Actions CI',
+      description: 'List workflow definitions and runs, and dispatch an explicitly named workflow_dispatch workflow.',
+      scopes: ['github:actions:read', 'github:actions:write'],
+      actions: ['list_workflows', 'list_workflow_runs', 'dispatch_workflow'],
+    },
   ];
 }
 
@@ -144,6 +170,74 @@ function githubActions(): AssistantPluginActionDescriptor[] {
         additionalProperties: false,
       },
     },
+    {
+      actionId: 'list_workflows',
+      title: 'List GitHub Actions workflows',
+      description: 'List workflow definitions for the configured GitHub repository.',
+      readOnly: true,
+      risk: 'readonly',
+      confirmation: 'none',
+      defaultTimeoutMs: 30_000,
+      cancellable: true,
+      idempotent: true,
+      scopes: ['github:actions:read'],
+      resourceClaims: [{ resource: 'remote', mode: 'read' }],
+      argumentsSchema: {
+        type: 'object',
+        properties: {
+          limit: { type: 'number', minimum: 1, maximum: 100 },
+          include_disabled: { type: 'boolean' },
+        },
+        additionalProperties: false,
+      },
+    },
+    {
+      actionId: 'list_workflow_runs',
+      title: 'List GitHub Actions runs',
+      description: 'List recent GitHub Actions workflow runs with optional workflow, branch, and status filters.',
+      readOnly: true,
+      risk: 'readonly',
+      confirmation: 'none',
+      defaultTimeoutMs: 30_000,
+      cancellable: true,
+      idempotent: true,
+      scopes: ['github:actions:read'],
+      resourceClaims: [{ resource: 'remote', mode: 'read' }],
+      argumentsSchema: {
+        type: 'object',
+        properties: {
+          workflow: { type: 'string' },
+          branch: { type: 'string' },
+          status: { type: 'string' },
+          limit: { type: 'number', minimum: 1, maximum: 100 },
+          include_disabled: { type: 'boolean' },
+        },
+        additionalProperties: false,
+      },
+    },
+    {
+      actionId: 'dispatch_workflow',
+      title: 'Dispatch GitHub Actions workflow',
+      description: 'Create a workflow_dispatch event for one explicitly named workflow.',
+      readOnly: false,
+      risk: 'remote_write',
+      confirmation: 'authorization',
+      defaultTimeoutMs: 60_000,
+      cancellable: true,
+      idempotent: false,
+      scopes: ['github:actions:write'],
+      resourceClaims: [{ resource: 'remote', mode: 'exclusive' }],
+      argumentsSchema: {
+        type: 'object',
+        properties: {
+          workflow: { type: 'string' },
+          ref: { type: 'string' },
+          inputs: { type: 'object', additionalProperties: { type: ['string', 'number', 'boolean'] } },
+        },
+        required: ['workflow'],
+        additionalProperties: false,
+      },
+    },
     {
       actionId: 'close_issue',
       title: 'Close linked GitHub issue',
@@ -252,6 +346,37 @@ export async function executeGitHubPluginAction(input: AssistantPluginActionExec
       return { issue: publishIssueWithGitHubPlugin(input.repoRoot, String(input.args.issue_id ?? '').trim()) };
     case 'refresh_issue':
       return refreshIssueWithGitHubPlugin(input.repoRoot, String(input.args.issue_id ?? '').trim()) as Record<string, unknown>;
+    case 'list_workflows': {
+      const config = loadGitHubPluginConfig(input.repoRoot);
+      return {
+        workflows: listGitHubWorkflows(input.repoRoot, config.repository, {
+          limit: typeof input.args.limit === 'number' ? input.args.limit : undefined,
+          includeDisabled: input.args.include_disabled === true,
+        }),
+      };
+    }
+    case 'list_workflow_runs': {
+      const config = loadGitHubPluginConfig(input.repoRoot);
+      return {
+        runs: listGitHubWorkflowRuns(input.repoRoot, config.repository, {
+          workflow: typeof input.args.workflow === 'string' ? input.args.workflow : undefined,
+          branch: typeof input.args.branch === 'string' ? input.args.branch : undefined,
+          status: typeof input.args.status === 'string' ? input.args.status : undefined,
+          limit: typeof input.args.limit === 'number' ? input.args.limit : undefined,
+          includeDisabled: input.args.include_disabled === true,
+        }),
+      };
+    }
+    case 'dispatch_workflow': {
+      const config = loadGitHubPluginConfig(input.repoRoot);
+      return dispatchGitHubWorkflow(input.repoRoot, config.repository, {
+        workflow: String(input.args.workflow ?? ''),
+        ref: typeof input.args.ref === 'string' ? input.args.ref : undefined,
+        inputs: input.args.inputs && typeof input.args.inputs === 'object' && !Array.isArray(input.args.inputs)
+          ? input.args.inputs as Record<string, string | number | boolean>
+          : undefined,
+      });
+    }
     case 'close_issue':
       return { issue: closeIssueWithGitHubPlugin(input.repoRoot, String(input.args.issue_id ?? '').trim()) };
     default:

package/src/runtime/plugins/gmail-adapter.ts

@@ -364,7 +364,33 @@ function gmailActions(): AssistantPluginActionDescriptor[] {
   ];
 }
 
-function buildMimeMessage(args: Record<string, unknown>, config: GmailPluginConfig): string {
+export function encodeMimeHeaderValue(value: string): string {
+  if (/[\r\n]/.test(value)) {
+    throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'MIME header values must not contain CR or LF.');
+  }
+  if (/^[\x00-\x7F]*$/.test(value)) return value;
+
+  // RFC 2047 encoded-words are limited to 75 characters including wrappers.
+  // 45 UTF-8 bytes encode to at most 60 Base64 characters, leaving room for
+  // the =?UTF-8?B?...?= wrapper. Split only at Unicode code-point boundaries.
+  const chunks: string[] = [];
+  let current = '';
+  for (const character of value) {
+    const candidate = `${current}${character}`;
+    if (current && Buffer.byteLength(candidate, 'utf8') > 45) {
+      chunks.push(current);
+      current = character;
+    } else {
+      current = candidate;
+    }
+  }
+  if (current) chunks.push(current);
+  return chunks
+    .map((chunk) => `=?UTF-8?B?${Buffer.from(chunk, 'utf8').toString('base64')}?=`)
+    .join('\r\n ');
+}
+
+export function buildMimeMessage(args: Record<string, unknown>, config: GmailPluginConfig): string {
   const to = stringArray(args.to);
   const cc = stringArray(args.cc);
   const bcc = stringArray(args.bcc);
@@ -378,7 +404,7 @@ function buildMimeMessage(args: Record<string, unknown>, config: GmailPluginConf
     ...(cc ? [`Cc: ${cc.join(', ')}`] : []),
     ...(bcc ? [`Bcc: ${bcc.join(', ')}`] : []),
     ...(config.accountEmail ? [`From: ${config.accountEmail}`] : []),
-    `Subject: ${subject}`,
+    `Subject: ${encodeMimeHeaderValue(subject)}`,
     'Content-Type: text/plain; charset="UTF-8"',
     'MIME-Version: 1.0',
     '',

package/src/runtime/plugins/ios/agent-device-provider.ts

@@ -14,7 +14,7 @@ export interface AgentDeviceProviderIdentity {
 export interface AgentDeviceSessionContext {
   stateDir: string;
   session: string;
-  device: string;
+  device?: string;
   platform: 'ios';
   requestId: string;
   cwd: string;

package/src/runtime/plugins/ios/agent-device-typed-provider.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, realpathSync } from 'fs';
 import { dirname, join } from 'path';
 import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
 import { AssistantPluginError } from '../errors';
 import type {
   AgentDeviceProviderIdentity,
@@ -26,8 +27,8 @@ interface TypedAgentDeviceModule {
 }
 
 interface TypedProviderHooks {
-  loadModule: () => Promise<TypedAgentDeviceModule>;
-  resolveModule: () => string | undefined;
+  loadModule: (resolvedModule?: string) => Promise<TypedAgentDeviceModule>;
+  resolveModule: (repoRoot?: string) => string | undefined;
   runtimeNodeVersion: () => string;
 }
 
@@ -76,7 +77,43 @@ function agentDevicePackageVersion(start: string): string | undefined {
   return undefined;
 }
 
-function defaultResolveModule(): string | undefined {
+function repoLocalModuleEntry(repoRoot?: string): string | undefined {
+  if (!repoRoot) return undefined;
+  const packageRoot = join(repoRoot, 'node_modules', AGENT_DEVICE_MODULE_NAME);
+  const packageJsonPath = join(packageRoot, 'package.json');
+  if (!existsSync(packageJsonPath)) return undefined;
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as {
+      name?: unknown;
+      main?: unknown;
+      exports?: unknown;
+    };
+    if (parsed.name !== AGENT_DEVICE_MODULE_NAME) return undefined;
+    const exportsRoot = parsed.exports && typeof parsed.exports === 'object' && !Array.isArray(parsed.exports)
+      ? (parsed.exports as Record<string, unknown>)['.']
+      : undefined;
+    const importEntry = exportsRoot && typeof exportsRoot === 'object' && !Array.isArray(exportsRoot)
+      ? (exportsRoot as Record<string, unknown>).import
+      : undefined;
+    const relativeEntry = typeof importEntry === 'string'
+      ? importEntry
+      : typeof exportsRoot === 'string'
+        ? exportsRoot
+        : typeof parsed.main === 'string'
+          ? parsed.main
+          : undefined;
+    if (!relativeEntry) return undefined;
+    const candidate = join(packageRoot, relativeEntry);
+    if (!existsSync(candidate)) return undefined;
+    try { return realpathSync(candidate); } catch { return candidate; }
+  } catch {
+    return undefined;
+  }
+}
+
+function defaultResolveModule(repoRoot?: string): string | undefined {
+  const local = repoLocalModuleEntry(repoRoot);
+  if (local) return local;
   try {
     return realpathSync(require.resolve(AGENT_DEVICE_MODULE_NAME));
   } catch {
@@ -84,8 +121,14 @@ function defaultResolveModule(): string | undefined {
   }
 }
 
+async function defaultLoadModule(resolvedModule?: string): Promise<TypedAgentDeviceModule> {
+  return resolvedModule
+    ? import(pathToFileURL(resolvedModule).href) as Promise<TypedAgentDeviceModule>
+    : import(AGENT_DEVICE_MODULE_NAME) as unknown as Promise<TypedAgentDeviceModule>;
+}
+
 let hooks: TypedProviderHooks = {
-  loadModule: async () => import(AGENT_DEVICE_MODULE_NAME) as unknown as TypedAgentDeviceModule,
+  loadModule: defaultLoadModule,
   resolveModule: defaultResolveModule,
   runtimeNodeVersion: () => process.versions.node,
 };
@@ -98,13 +141,13 @@ export function setAgentDeviceTypedProviderHooksForTest(
 
 export function resetAgentDeviceTypedProviderHooksForTest(): void {
   hooks = {
-    loadModule: async () => import(AGENT_DEVICE_MODULE_NAME) as unknown as TypedAgentDeviceModule,
+    loadModule: defaultLoadModule,
     resolveModule: defaultResolveModule,
     runtimeNodeVersion: () => process.versions.node,
   };
 }
 
-export function typedAgentDeviceIdentity(): AgentDeviceProviderIdentity {
+export function typedAgentDeviceIdentity(options: { repoRoot?: string } = {}): AgentDeviceProviderIdentity {
   const runtimeVersion = hooks.runtimeNodeVersion();
   if (!versionAtLeast(runtimeVersion, MIN_TYPED_CLIENT_NODE_VERSION)) {
     return {
@@ -115,7 +158,7 @@ export function typedAgentDeviceIdentity(): AgentDeviceProviderIdentity {
       reason: `The optional agent-device typed client requires Node >=${MIN_TYPED_CLIENT_NODE_VERSION}; current runtime is ${runtimeVersion || 'unknown'}.`,
     };
   }
-  const resolvedModule = hooks.resolveModule();
+  const resolvedModule = hooks.resolveModule(options.repoRoot);
   if (!resolvedModule) {
     return {
       kind: 'typed',
@@ -194,7 +237,7 @@ function snapshotOptions(
 ): Record<string, unknown> {
   return {
     platform: context.platform,
-    device: context.device,
+    ...(context.device ? { device: context.device } : {}),
     session: context.session,
     requestId: context.requestId,
     interactiveOnly: request.interactiveOnly === true,
@@ -227,7 +270,7 @@ export class TypedAgentDeviceReadProvider implements AgentDeviceReadProvider {
     }
     let module: TypedAgentDeviceModule;
     try {
-      module = await hooks.loadModule();
+      module = await hooks.loadModule(this.identity.resolvedModule);
     } catch (error) {
       throw new AssistantPluginError(
         'AGENT_DEVICE_TYPED_PROVIDER_UNAVAILABLE',